// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/processor/cnfoptimizer.cpp
// Function: bal::CnfOptimizer::evaluate_clause_a(unsigned int*, unsigned int, unsigned int)
inline processor_result_t CnfOptimizer::evaluate_clause_a(uint32_t* const p_clause,
                                                               container_offset_t offset,
                                                               const container_offset_t original_offset) {
        // the clause which originated the current one after normalization
        _assert_level_2(original_offset <= processed_offset_ || original_offset == CONTAINER_END);
        
        // offset that the resulting clause can be stored to
        const container_offset_t update_offset = clauses_.transaction_offset_is_immutable(original_offset) ? CONTAINER_END : original_offset;
        
        // the clause may be updated several times
        // the processing stops when the last iteration results in erUndetermined
        // however, the returned value reflects preceding change
        processor_result_t result = erUndetermined;
        
        // repeat processing for as long as the clause is changed, at least once
        while(true) {
            evaluations_aggregated_++;
            
            const clause_size_t clause_size = _clause_size(p_clause);
            if (clause_size > 1) {
                // "processed" clause flags from offset clause
                // 0 for first time processing, actual for processed clauses
                // referring to the baseline for already generated subsuming clauses;
                // it is used for merging and deriving of reduced clauses to only process the changes
                clause_flags_t processed_flags = offset < processed_offset_ ? _clauses_offset_flags(clauses_data_, offset) : 0;
                
                // insertion point stores index position when a clause is searched for
                // it will be used if thenew clause is appended
                Cnf::clauses_container_t::insertion_point_t insertion_point;
                __insertion_point_t_init(insertion_point);
                
                if (offset == CONTAINER_END) {
                    // find existing matching clause before evaluation
                    // note that the result may be beyond processed_offset_ and that
                    // it can be equal to processed_offset_ while evaluating recursively
                    clauses_.find(p_clause, insertion_point);
                    offset = insertion_point.container_offset;
                    if (offset < processed_offset_) {
                        processed_flags = _clauses_offset_flags(clauses_data_, offset);
                    };
                };
                
                // there is offset but not the current clause
                if (offset != CONTAINER_END && (original_offset != processed_offset_ || offset != original_offset)) {
                    const clause_flags_t offset_flags = _clauses_offset_flags(clauses_data_, offset);
                    _assert_level_1(offset_flags);
                    _clause_flags_include(p_clause, offset_flags);
                    if (_clause_flags(p_clause) != offset_flags) {
                        TRACE_CLAUSE_MERGE(p_clause, offset);
                        if (clauses_.transaction_offset_is_immutable(offset)) {
                            // once changed, an immutable clause will be appended afresh
                            // the original clause must be excluded
                            exclude_clause(offset);
                            clauses_.insertion_point_from_container_offset(insertion_point, offset);
                            offset = CONTAINER_END;
                            TRACE_CLAUSE_UPDATE(p_clause, offset);
                        } else if (!is_clause_included(offset)) {
                            _assert_level_1(offset != processed_offset_); // unelaborated and untested
                            if (offset < processed_offset_) {
                                // if the clause is processed, treat is as immutable
                                clauses_.insertion_point_from_container_offset(insertion_point, offset);
                                offset = CONTAINER_END;
                                TRACE_CLAUSE_UPDATE(p_clause, offset);
                            } else if (offset > processed_offset_) {
                                // this essentially re-includes the clause
                                // which is fine assuming the clause is not included into variable clauses index yet
                                _assert_level_1(_clause_is_included(p_clause));
                                _clauses_offset_header(clauses_data_, offset) = _clause_header(p_clause);
                                TRACE_CLAUSE_UPDATE(p_clause, offset);
                                TRACE_CLAUSE_APPEND(p_clause);
                            };
                        } else if (offset > processed_offset_ && update_offset != CONTAINER_END) {
                            // merge the unprocessed clause into the current one
                            exclude_clause(offset);
                            clauses_.insertion_point_from_container_offset(insertion_point, offset);
                            offset = CONTAINER_END;
                            TRACE_CLAUSE_UPDATE(p_clause, offset);
                        } else {
                            // must be updated immediately for cascade updates
                            // and even if excluded, in case it is included again
                            _clauses_offset_flags_include(clauses_data_, offset, _clause_flags(p_clause));
                            TRACE_CLAUSE_UPDATE(p_clause, offset);
                        };
                    } else {
                        // p_clause is fully merged into an existing one
                        break;
                    };
                };
                
                processor_result_t iteration_result = erUndetermined;
                const clause_flags_t flags = _clause_flags(p_clause);
                // there is something to process
                _assert_level_1((flags & ~processed_flags) != 0);
                // ensure processed flags is a subset (merged)
                _assert_level_1((~flags & processed_flags) == 0);
                
                if (clause_size == 2) {
                    
                    if (_c2_is_single_clause_flags(flags)) {
                        // a single clause cannot be reprocessed again since it cannot change
                        // this also means an immutable clause will not be re-insserted
                        // clause is ignored if offset is unprocessed
                        _assert_level_1(offset >= processed_offset_);
                        if ((original_offset == processed_offset_ && offset == original_offset) ||
                            (update_offset == processed_offset_ && offset == CONTAINER_END)) {
                            processor_result_t resolve_result = resolve_c2(p_clause);
                            _assert_level_3(resolve_result == erSatisfied || resolve_result == erConflict || normalize_ca(p_clause, p_clause) == erUndetermined);
                            iteration_result = (resolve_result == erUndetermined) ? iteration_result : resolve_result;
                        };
                    } else {
                        // the result is always resolved fully
                        if (offset != CONTAINER_END) {
                            exclude_clause(offset);
                            offset = CONTAINER_END;
                        };
                        
                        const literalid_t* const variables = variables_.data();
                        const literalid_t* const literals = _clause_literals(p_clause);
                        
                        if (flags == 0b0110 || flags == 0b1001) {
                            // found full equivalence
                            const literalid_t lhs = variables[literal_t__variable_id(literals[1])];
                            const literalid_t rhs = literal_t__negated_onlyif(literals[0], flags == 0b1001);
                            if (literal_t__is_constant(lhs) && literal_t__is_variable(rhs)) {
                                // TODO: why is this possible????
                                iteration_result = assign_literal_value(rhs, lhs);
                            } else if (lhs != rhs) {
                                iteration_result = assign_literal_value(literals[1], rhs);
                            } else {
                                iteration_result = erSatisfied;
                            };
                        } else if (flags == 0b0101 || flags == 0b1010) {
                            // first variable value is inferred
                            iteration_result = assign_literal_value(literals[0], literal_t__constant(flags == 0b1010));
                        } else if (flags == 0b0011 || flags == 0b1100) {
                            // second variable value is inferred
                            iteration_result = assign_literal_value(literals[1], literal_t__constant(flags == 0b1100));
                        } else if (flags == 0b0111 || flags == 0b1011 || flags == 0b1101 || flags == 0b1110) {
                            // both variable values are inferred
                            // note that the second variable may be resolved while assigning the first one
                            // see notes within assign_literal_value()
                            iteration_result = assign_literal_value(literals[0],
                                                                    literal_t__constant((flags & 0b1010) == 0b1010));
                            if (iteration_result != erConflict) {
                                iteration_result = assign_literal_value(literals[1],
                                                                        literal_t__constant((_clause_flags(p_clause) & 0b1100) == 0b1100));
                            };
                        } else {
                            iteration_result = erConflict;
                        };
                    };
                    
                } else if (clause_size == 3) {
                } else if (clause_size == 4) {
                    _assert_level_3(offset == CONTAINER_END || is_clause_included(offset));
                } else {
                    _assert_level_0(false);
                };
                
                // POST-PROCESSING
                result = (iteration_result == erUndetermined) ? result : iteration_result;
                
                if (iteration_result == erUndetermined && offset == CONTAINER_END) {
                    _assert_level_1(_clause_is_included(p_clause));
                    _assert_level_1(update_offset == CONTAINER_END ||
                                    !_clauses_offset_is_included(clauses_data_, update_offset));
                    // something happened while processing recursively
                    if (!clauses_.insertion_point_is_valid(insertion_point)) {
                        clauses_.find(p_clause, insertion_point);
                        offset = insertion_point.container_offset;
                        if (offset != CONTAINER_END) {
                            _assert_level_1(offset != update_offset);
                            uint32_t* const p_found_clause = _clauses_offset_clause(clauses_data_, offset);
                            const clause_flags_t found_flags = _clause_flags(p_found_clause);
                            
                            if (update_offset < offset) {
                                // use update_offset in any case
                                if (found_flags & ~_clause_flags(p_clause)) {
                                    // reprocess the current clause to merge it
                                    continue;
                                } else {
                                    // offset is replaced by p_clause
                                    exclude_clause(offset);
                                };
                            } else if (offset <= processed_offset_) {
                                if ((~found_flags & _clause_flags(p_clause)) == 0) {
                                    // found processed offset includes p_clause
                                    // simply ignore p_clause and keep offset
                                    break;
                                } else {
                                    // offset clause has something p_clause doesn't
                                    // or p_clause has something offset doesn't
                                    // reprocess; immutable and excluded offset will be handled properly
                                    _assert_level_1(offset != processed_offset_);
                                    continue;
                                };
                            } else {
                                if (_clause_flags(p_clause) & ~found_flags) {
                                    // an unprocessed clause and there are new flags to add
                                    if (clauses_.transaction_offset_is_immutable(offset) ||
                                        !_clause_is_included(p_found_clause)) {
                                        _clause_flags_include(p_clause, found_flags);
                                        exclude_clause(offset);
                                    } else {
                                        _clause_flags_include(p_found_clause, _clause_flags(p_clause));
                                        TRACE_CLAUSE_MERGE(p_clause, offset);
                                        break;
                                    };
                                } else {
                                    // an unprocessed clause, no new flags
                                    // ignore the current clause
                                    // if the found clause is excluded that is for a reason
                                    break;
                                };
                            };
                        };
                        _assert_level_2(offset == insertion_point.container_offset);
                    } else {
                        offset = insertion_point.container_offset;
                        if (offset != CONTAINER_END) {
                            if (_clauses_offset_is_included(clauses_data_, offset)) {
                                if ((_clauses_offset_flags(clauses_data_, offset) & ~_clause_flags(p_clause)) != 0) {
                                    // additional clauses were resolved recursively; reprocess
                                    _assert_level_1(offset != processed_offset_);
                                    continue;
                                };
                            };
                        };
                    };
                    
                    if (update_offset != CONTAINER_END) {
                        if (offset != CONTAINER_END) {
                            if (_clauses_offset_is_included(clauses_data_, offset)) {
                                // additional clauses derived while processing recursively
                                _assert_level_2(offset > processed_offset_);
                                _assert_level_3((_clauses_offset_flags(clauses_data_, offset) & ~_clause_flags(p_clause)) == 0);
                                exclude_clause(offset);
                                offset = CONTAINER_END;
                            };
                        };
                        // copying must occur afterwards to indentify the old clause
                        clauses_.update(update_offset, insertion_point);
                        _assert_level_1(_clause_is_included(p_clause));
                        _clause_copy(p_clause, _clauses_offset_clause(clauses_data_, update_offset));
                        // see note 1
                    } else {
                        clauses_.append<true>(p_clause, insertion_point);
                    };
                    
                    TRACE_CLAUSE_APPEND(p_clause);
                    break;
                } else if (iteration_result == erChangedC || iteration_result == erChangedV) {
                    if (offset != CONTAINER_END) {
                        exclude_clause(offset);
                        offset = CONTAINER_END;
                    };
                    TRACE_CLAUSE_RESOLVENT(p_clause);
                    continue;
                } else if (iteration_result == erSatisfied) {
                    if (offset != CONTAINER_END) {
                        exclude_clause(offset);
                    };
                    break;
                } else {
                    break;
                };
                
            } else if (clause_size == 1) {
                const clause_flags_t flags = _clause_flags(p_clause);
                if (flags == 0b11) {
                    result = erConflict;
                } else {
                    result = assign_literal_value(_clause_literal(p_clause, 0), literal_t__constant(flags == 0b10));
                };
                break;
            } else { // clause_size == 0
                result = erConflict;
                break;
            };
        };
        
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r9
cmpl $-0x1, %ecx
je 0x12c11
cmpl %ecx, 0xb0(%r9)
jb 0x134e6
movq 0x10(%r9), %rax
movl 0x50(%rax), %eax
cmpl %ecx, %eax
pushq $-0x1
popq %rsi
movl %ecx, %edx
cmoval %esi, %edx
cmpl $-0x1, %eax
movl %ecx, -0x54(%rbp)
cmovel %ecx, %edx
movq %rdx, -0x60(%rbp)
xorl %r14d, %r14d
movq %r9, -0x38(%rbp)
movq %r15, -0x40(%rbp)
incq 0xc8(%r9)
movl (%r15), %eax
movl %eax, %r12d
andl $0x7fff, %r12d          # imm = 0x7FFF
cmpl $0x2, %r12d
jb 0x131e2
movl 0xb0(%r9), %eax
cmpl %eax, %ebx
jae 0x12c77
movq 0x18(%r9), %rcx
movq (%rcx), %rcx
movl %ebx, %edx
movzwl 0xe(%rcx,%rdx,4), %edx
orl $-0x1, -0x4c(%rbp)
jmp 0x12cc3
orl $-0x1, -0x4c(%rbp)
cmpl $-0x1, %ebx
je 0x12c84
xorl %edx, %edx
jmp 0x12cc3
movq 0x10(%r9), %rdi
movq %r15, %rsi
leaq -0x50(%rbp), %rdx
callq 0xfccc
movq -0x38(%rbp), %r9
movl -0x50(%rbp), %ebx
movl 0xb0(%r9), %eax
cmpl %eax, %ebx
jae 0x12cb4
movq 0x18(%r9), %rcx
movq (%rcx), %rcx
movzwl 0xe(%rcx,%rbx,4), %edx
jmp 0x12cc3
xorl %edx, %edx
pushq $-0x1
popq %r13
cmpl $-0x1, %ebx
je 0x12e2e
movl -0x54(%rbp), %r13d
xorl %r13d, %eax
movl %ebx, %ecx
xorl %r13d, %ecx
orl %eax, %ecx
je 0x12e2e
movq 0x18(%r9), %rax
movq (%rax), %rax
movl %ebx, %r13d
movl 0xc(%rax,%r13,4), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jbe 0x133ee
movl %eax, %ecx
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl (%r15), %ecx
movl %ecx, (%r15)
xorl %eax, %ecx
cmpl $0x10000, %ecx          # imm = 0x10000
jb 0x1337f
movl %edx, -0x2c(%rbp)
movq 0x3e5e9(%rip), %rdi     # 0x51300
testq %rdi, %rdi
je 0x12d2b
movq (%rdi), %rax
movq %r15, %rsi
movl %ebx, %edx
callq *0x58(%rax)
movq -0x38(%rbp), %r9
movq 0x10(%r9), %rdi
movl 0x50(%rdi), %eax
cmpl $-0x1, %eax
je 0x12d78
cmpl %ebx, %eax
jbe 0x12d78
movq %r9, %rdi
movl %ebx, %esi
movq %r9, %r13
callq 0x135c0
movq 0x10(%r13), %rdi
leaq -0x50(%rbp), %rsi
movl %ebx, %edx
callq 0x13852
movq 0x3e5a2(%rip), %rdi     # 0x51300
testq %rdi, %rdi
je 0x12dc9
movq (%rdi), %rax
movq %r15, %rsi
pushq $-0x1
popq %r13
movl %r13d, %edx
pushq $0x1
popq %rcx
callq *0x40(%rax)
jmp 0x12dcd
movq 0x18(%r9), %rax
movq (%rax), %rax
movl 0xc(%rax,%r13,4), %ecx
movl 0xb0(%r9), %edx
testw %cx, %cx
js 0x12dd3
cmpl $-0x1, -0x60(%rbp)
je 0x12d9a
cmpl %edx, %ebx
ja 0x12d3b
movzwl 0x2(%r15), %edx
shll $0x10, %edx
orl %ecx, %edx
movl %edx, 0xc(%rax,%r13,4)
movq 0x3e550(%rip), %rdi     # 0x51300
testq %rdi, %rdi
je 0x12e28
movq (%rdi), %rax
movq %r15, %rsi
movl %ebx, %edx
pushq $0x1
popq %rcx
callq *0x40(%rax)
movq -0x38(%rbp), %r9
jmp 0x12e28
pushq $-0x1
popq %r13
movq -0x38(%rbp), %r9
jmp 0x12e2b
cmpl %edx, %ebx
je 0x134c7
jb 0x12d4c
jbe 0x12e28
movl (%r15), %ecx
testw %cx, %cx
js 0x13524
movl %ecx, 0xc(%rax,%r13,4)
movq 0x3e505(%rip), %rdi     # 0x51300
testq %rdi, %rdi
je 0x12e28
movq (%rdi), %rax
movq %r15, %rsi
movl %ebx, %edx
pushq $0x1
popq %rcx
callq *0x40(%rax)
movq 0x3e4eb(%rip), %rdi     # 0x51300
testq %rdi, %rdi
je 0x12e23
movq (%rdi), %rax
movq %r15, %rsi
callq *0x50(%rax)
movl %ebx, %r13d
jmp 0x12dcd
movl %ebx, %r13d
movl -0x2c(%rbp), %edx
movl %r14d, -0x2c(%rbp)
movl (%r15), %r15d
movl %r15d, %r14d
shrl $0x10, %r14d
movzwl %dx, %eax
movl %eax, %ecx
notl %ecx
testl %ecx, %r14d
je 0x13391
movl %r14d, %ecx
notl %ecx
testl %eax, %ecx
jne 0x133b0
xorl %ebx, %ebx
cmpl $0x4, %r12d
je 0x12ef2
cmpl $0x3, %r12d
je 0x12ee9
cmpl $0x2, %r12d
jne 0x1340d
cmpl $0x8, %r14d
movq -0x60(%rbp), %r12
ja 0x12f3d
movl $0x116, %eax            # imm = 0x116
btl %r14d, %eax
jae 0x12f3d
movl 0xb0(%r9), %eax
cmpl %eax, %r13d
jb 0x1344b
movl %eax, %ecx
movl -0x54(%rbp), %esi
xorl %esi, %ecx
movl %r13d, %edx
xorl %esi, %edx
orl %ecx, %edx
movq -0x40(%rbp), %r14
je 0x12ec9
cmpl $-0x1, %r13d
jne 0x13042
cmpl %eax, %r12d
jne 0x13042
movq %r9, %rdi
movq %r14, %rsi
movq %r9, %r15
callq 0x13908
movl %eax, %ebx
addl $-0x3, %eax
cmpl $0x2, %eax
jae 0x12f1f
movq %r15, %r9
jmp 0x13042
movq -0x60(%rbp), %r12
jmp 0x13042
cmpl $-0x1, %r13d
movq -0x60(%rbp), %r12
je 0x12f16
movq 0x18(%r9), %rax
movq (%rax), %rax
movl %r13d, %ecx
testb $-0x80, 0xd(%rax,%rcx,4)
je 0x13042
jmp 0x134a8
pushq $-0x1
popq %r13
jmp 0x13042
movq %r15, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0x11624
testl %eax, %eax
movq %r15, %r9
je 0x13042
jmp 0x13505
cmpl $-0x1, %r13d
je 0x12f52
movq %r9, %rdi
movl %r13d, %esi
callq 0x135c0
movq -0x38(%rbp), %r9
movzwl %r14w, %eax
addl $-0x3, %eax
pushq $0x4
popq %rcx
movl %ecx, %ebx
pushq $-0x1
popq %r13
cmpl $0xb, %eax
ja 0x13042
leaq 0x20e2a(%rip), %rcx     # 0x33d9c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
pushq $0x4
popq %rcx
movl %ecx, %ebx
jmpq *%rax
movq -0x40(%rbp), %rax
movl 0x4(%rax), %esi
notl %r15d
xorl %edx, %edx
testl $0xa0000, %r15d         # imm = 0xA0000
sete %dl
movq %r9, %rdi
callq 0x13aae
movq -0x38(%rbp), %r9
pushq $0x4
popq %rcx
movl %ecx, %ebx
cmpl $0x4, %eax
je 0x13042
movq -0x40(%rbp), %rcx
movl (%rcx), %eax
movl 0x8(%rcx), %esi
notl %eax
xorl %edx, %edx
testl $0xc0000, %eax          # imm = 0xC0000
sete %dl
jmp 0x13034
xorl %edx, %edx
cmpl $0xa, %r14d
sete %dl
movq -0x40(%rbp), %rax
movl 0x4(%rax), %esi
jmp 0x13034
xorl %edx, %edx
cmpl $0xc, %r14d
sete %dl
movq -0x40(%rbp), %rax
movl 0x8(%rax), %esi
jmp 0x13034
xorl %edx, %edx
cmpl $0x9, %r14d
sete %dl
movq 0xb8(%r9), %rax
movq (%rax), %rax
movq -0x40(%rbp), %rsi
movl 0x4(%rsi), %ecx
movl 0x8(%rsi), %esi
movl %esi, %edi
shrl %edi
decl %edi
movl (%rax,%rdi,4), %eax
xorl %ecx, %edx
cmpl $0x1, %eax
ja 0x1302b
cmpl $0x2, %ecx
jb 0x1302b
cmpl $-0x1, %edx
je 0x1302b
movq %r9, %rdi
movl %edx, %esi
movl %eax, %edx
jmp 0x13037
pushq $0x3
popq %rcx
movl %ecx, %ebx
cmpl %edx, %eax
je 0x13042
movq %r9, %rdi
callq 0x13aae
movq -0x38(%rbp), %r9
movl %eax, %ebx
testl %ebx, %ebx
movl -0x2c(%rbp), %r14d
cmovnel %ebx, %r14d
jne 0x130ed
cmpl $-0x1, %r13d
jne 0x130ed
movq -0x40(%rbp), %r15
testb $-0x80, 0x1(%r15)
jne 0x133cf
cmpl $-0x1, %r12d
leaq -0x50(%rbp), %rsi
je 0x13088
movq 0x18(%r9), %rax
movq (%rax), %rax
testb $-0x80, 0xd(%rax,%r12,4)
je 0x1342c
movq 0x10(%r9), %rdi
movq (%rdi), %rax
movq %rsi, %r13
movq %r9, %rbx
callq *0x8(%rax)
testb %al, %al
je 0x13141
movl -0x50(%rbp), %ebx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rbx
je 0x1323b
movq -0x38(%rbp), %r9
movq 0x18(%r9), %rax
movq (%rax), %rax
movl 0xc(%rax,%rbx,4), %eax
testw %ax, %ax
js 0x132c7
movl (%r15), %ecx
notl %ecx
andl %ecx, %eax
cmpl $0x10000, %eax          # imm = 0x10000
jb 0x132c7
cmpl 0xb0(%r9), %ebx
jne 0x12c3a
jmp 0x13489
leal -0x1(%rbx), %eax
cmpl $0x1, %eax
movq -0x40(%rbp), %r15
ja 0x13218
cmpl $-0x1, %r13d
je 0x13112
movq %r9, %rdi
movl %r13d, %esi
callq 0x135c0
movq -0x38(%rbp), %r9
movq 0x3e1e7(%rip), %rdi     # 0x51300
pushq $-0x1
popq %rax
movl %eax, %ebx
testq %rdi, %rdi
je 0x12c3a
movq (%rdi), %rax
movq %r15, %rsi
pushq $-0x1
popq %rbx
movl %ebx, %edx
pushq $0x1
popq %rcx
callq *0x40(%rax)
movq -0x38(%rbp), %r9
jmp 0x12c3a
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xfccc
movl -0x50(%rbp), %ebx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rbx
je 0x132ba
cmpl %r12d, %ebx
je 0x1346a
movq -0x38(%rbp), %r9
movq 0x18(%r9), %rax
movq (%rax), %rcx
movl 0xc(%rcx,%rbx,4), %eax
movl %eax, %esi
shrl $0x10, %esi
cmpl %ebx, %r12d
jae 0x13197
movzwl 0x2(%r15), %eax
notl %eax
testl %eax, %esi
jne 0x12c3a
jmp 0x132b0
movl 0xb0(%r9), %edi
movl (%r15), %edx
movl %edx, %r8d
shrl $0x10, %r8d
notl %esi
cmpl %edi, %ebx
ja 0x1324e
testl %esi, %r8d
je 0x1337f
cmpl %edi, %ebx
jne 0x12c3a
leaq 0x218cf(%rip), %rdi     # 0x34a99
leaq 0x20c37(%rip), %rsi     # 0x33e08
leaq 0x2183d(%rip), %rcx     # 0x34a15
movl $0x248, %edx            # imm = 0x248
callq 0xc180
pushq $0x4
popq %r14
cmpl $0x1, %r12d
jne 0x1337f
shrl $0x10, %eax
cmpl $0x3, %eax
je 0x1337f
movl 0x4(%r15), %esi
xorl %edx, %edx
cmpl $0x2, %eax
sete %dl
movq %r9, %rdi
callq 0x13aae
movl %eax, %r14d
jmp 0x1337f
cmpl $0x3, %ebx
jne 0x1337f
cmpl $-0x1, %r13d
je 0x1337f
movq %r9, %rdi
movl %r13d, %esi
callq 0x135c0
jmp 0x1337f
cmpl $-0x1, %r12d
movq -0x38(%rbp), %r9
jne 0x13315
jmp 0x1335a
testl %esi, %r8d
je 0x1337f
movq 0x10(%r9), %rsi
movl 0x50(%rsi), %esi
cmpl $-0x1, %esi
setne %dil
cmpl %ebx, %esi
seta %sil
testb %sil, %dil
jne 0x132a6
movl %eax, %esi
andl $0x8000, %esi           # imm = 0x8000
jne 0x132a6
andl $0xffff0000, %edx       # imm = 0xFFFF0000
orl %eax, %edx
movl %edx, 0xc(%rcx,%rbx,4)
movq 0x3e073(%rip), %rdi     # 0x51300
testq %rdi, %rdi
je 0x1337f
movq (%rdi), %rax
movq %r15, %rsi
movl %ebx, %edx
callq *0x58(%rax)
jmp 0x1337f
andl $0xffff0000, %eax       # imm = 0xFFFF0000
orl %eax, %edx
movl %edx, (%r15)
movq %r9, %rdi
movl %ebx, %esi
callq 0x135c0
cmpl -0x50(%rbp), %ebx
movq -0x38(%rbp), %r9
jne 0x13562
cmpl $-0x1, %r12d
je 0x1335a
cmpl $-0x1, %ebx
je 0x13315
movq 0x18(%r9), %rax
movq (%rax), %rax
movl %ebx, %ecx
movl 0xc(%rax,%rcx,4), %eax
testw %ax, %ax
js 0x13315
cmpl 0xb0(%r9), %ebx
jbe 0x13581
movl (%r15), %ecx
notl %ecx
andl %ecx, %eax
cmpl $0x10000, %eax          # imm = 0x10000
jae 0x135a0
movq %r9, %rdi
movl %ebx, %esi
callq 0x135c0
movq -0x38(%rbp), %r9
movq 0x10(%r9), %rdi
leaq -0x50(%rbp), %rdx
movl %r12d, %esi
movq %r9, %rbx
callq 0x13608
movl (%r15), %eax
testw %ax, %ax
js 0x13543
andl $0x7fff, %eax           # imm = 0x7FFF
leaq 0x4(,%rax,4), %rdx
movq 0x18(%rbx), %rax
movq (%rax), %rax
leaq (%rax,%r12,4), %rdi
addq $0xc, %rdi
movq %r15, %rsi
callq 0xc440
jmp 0x1336a
movq 0x10(%r9), %rdi
leaq -0x50(%rbp), %rdx
movq %r15, %rsi
callq 0x10fa8
movq 0x3df8f(%rip), %rdi     # 0x51300
testq %rdi, %rdi
je 0x1337f
movq (%rdi), %rax
movq %r15, %rsi
callq *0x50(%rax)
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2171d(%rip), %rdi     # 0x34ab5
leaq 0x20a69(%rip), %rsi     # 0x33e08
leaq 0x2166f(%rip), %rcx     # 0x34a15
movl $0x1e3, %edx            # imm = 0x1E3
callq 0xc180
leaq 0x2171e(%rip), %rdi     # 0x34ad5
leaq 0x20a4a(%rip), %rsi     # 0x33e08
leaq 0x21650(%rip), %rcx     # 0x34a15
movl $0x1e5, %edx            # imm = 0x1E5
callq 0xc180
leaq 0x1ffcf(%rip), %rdi     # 0x333a5
leaq 0x20a2b(%rip), %rsi     # 0x33e08
leaq 0x21631(%rip), %rcx     # 0x34a15
movl $0x22a, %edx            # imm = 0x22A
callq 0xc180
leaq 0x21697(%rip), %rdi     # 0x34a8c
leaq 0x20a0c(%rip), %rsi     # 0x33e08
leaq 0x21612(%rip), %rcx     # 0x34a15
movl $0x1b4, %edx            # imm = 0x1B4
callq 0xc180
leaq 0x269a7(%rip), %rdi     # 0x39dbb
leaq 0x209ed(%rip), %rsi     # 0x33e08
leaq 0x215f3(%rip), %rcx     # 0x34a15
movl $0x223, %edx            # imm = 0x223
callq 0xc180
leaq 0x21788(%rip), %rdi     # 0x34bbb
leaq 0x209ce(%rip), %rsi     # 0x33e08
leaq 0x215d4(%rip), %rcx     # 0x34a15
movl $0x22c, %edx            # imm = 0x22C
callq 0xc180
leaq 0x216a3(%rip), %rdi     # 0x34af5
leaq 0x209af(%rip), %rsi     # 0x33e08
leaq 0x215b5(%rip), %rcx     # 0x34a15
movl $0x1ed, %edx            # imm = 0x1ED
callq 0xc180
leaq 0x217b4(%rip), %rdi     # 0x34c25
leaq 0x20990(%rip), %rsi     # 0x33e08
leaq 0x21596(%rip), %rcx     # 0x34a15
movl $0x232, %edx            # imm = 0x232
callq 0xc180
leaq 0x21609(%rip), %rdi     # 0x34a99
leaq 0x20971(%rip), %rsi     # 0x33e08
leaq 0x21577(%rip), %rcx     # 0x34a15
movl $0x266, %edx            # imm = 0x266
callq 0xc180
leaq 0x216d6(%rip), %rdi     # 0x34b85
leaq 0x20952(%rip), %rsi     # 0x33e08
leaq 0x21558(%rip), %rcx     # 0x34a15
movl $0x221, %edx            # imm = 0x221
callq 0xc180
leaq 0x215cb(%rip), %rdi     # 0x34a99
leaq 0x20933(%rip), %rsi     # 0x33e08
leaq 0x21539(%rip), %rcx     # 0x34a15
movl $0x1c0, %edx            # imm = 0x1C0
callq 0xc180
leaq 0x214df(%rip), %rdi     # 0x349cc
leaq 0x20914(%rip), %rsi     # 0x33e08
leaq 0x2151a(%rip), %rcx     # 0x34a15
movl $0x18b, %edx            # imm = 0x18B
callq 0xc180
leaq 0x21605(%rip), %rdi     # 0x34b11
leaq 0x208f5(%rip), %rsi     # 0x33e08
leaq 0x214fb(%rip), %rcx     # 0x34a15
movl $0x1f1, %edx            # imm = 0x1F1
callq 0xc180
leaq 0x1fe7a(%rip), %rdi     # 0x333a5
leaq 0x208d6(%rip), %rsi     # 0x33e08
leaq 0x214dc(%rip), %rcx     # 0x34a15
movl $0x1c9, %edx            # imm = 0x1C9
callq 0xc180
leaq 0x1fe5b(%rip), %rdi     # 0x333a5
leaq 0x208b7(%rip), %rsi     # 0x33e08
leaq 0x214bd(%rip), %rcx     # 0x34a15
movl $0x279, %edx            # imm = 0x279
callq 0xc180
leaq 0x216d4(%rip), %rdi     # 0x34c3d
leaq 0x20898(%rip), %rsi     # 0x33e08
leaq 0x2149e(%rip), %rcx     # 0x34a15
movl $0x25f, %edx            # imm = 0x25F
callq 0xc180
leaq 0x216e0(%rip), %rdi     # 0x34c68
leaq 0x20879(%rip), %rsi     # 0x33e08
leaq 0x2147f(%rip), %rcx     # 0x34a15
movl $0x271, %edx            # imm = 0x271
callq 0xc180
leaq 0x216dc(%rip), %rdi     # 0x34c83
leaq 0x2085a(%rip), %rsi     # 0x33e08
leaq 0x21460(%rip), %rcx     # 0x34a15
movl $0x272, %edx            # imm = 0x272
callq 0xc180
nop