// File: /workspace/github_cpp_makefile_star2_O3/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 $0x48, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r9
cmpl $-0x1, %ecx
je 0x14638
cmpl %ecx, 0xb0(%r9)
jb 0x1531c
movq 0x10(%r9), %rax
movl 0x50(%rax), %eax
cmpl %ecx, %eax
movl %ecx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmovbel %edx, %ecx
cmpl $-0x1, %eax
movl %edx, -0x54(%rbp)
cmovel %edx, %ecx
incq 0xc8(%r9)
movl (%r15), %eax
movl %eax, %r13d
andl $0x7fff, %r13d          # imm = 0x7FFF
cmpl $0x2, %r13d
jb 0x1501e
movl %ecx, -0x34(%rbp)
movl %ecx, %eax
movq %rax, -0x68(%rbp)
movq $0x0, -0x60(%rbp)
movq %r9, -0x30(%rbp)
movl 0xb0(%r9), %eax
cmpl %eax, %r14d
jae 0x146ae
movq 0x18(%r9), %rcx
movq (%rcx), %rcx
movl %r14d, %edx
movzwl 0xe(%rcx,%rdx,4), %edi
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
movl -0x54(%rbp), %ecx
jmp 0x146c4
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
xorl %edi, %edi
cmpl $-0x1, %r14d
movl -0x54(%rbp), %ecx
je 0x1483a
cmpl %ecx, %eax
jne 0x146d8
cmpl %ecx, %r14d
jne 0x146d8
movl %ecx, %eax
movq %rax, -0x50(%rbp)
jmp 0x14a5b
movq 0x18(%r9), %rax
movq (%rax), %rax
movl %r14d, %r12d
movl 0xc(%rax,%r12,4), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jbe 0x152fd
movl %eax, %ecx
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl (%r15), %ecx
movl %ecx, (%r15)
xorl %eax, %ecx
cmpl $0x10000, %ecx          # imm = 0x10000
jb 0x1517f
movl %edi, %ebx
movq 0x47bf9(%rip), %rdi     # 0x5c310
testq %rdi, %rdi
je 0x1472c
movq (%rdi), %rax
movq %r15, %rsi
movl %r14d, %edx
callq *0x58(%rax)
movq -0x30(%rbp), %r9
movq 0x10(%r9), %rax
movl 0x50(%rax), %ecx
cmpl $-0x1, %ecx
je 0x147d2
cmpl %r14d, %ecx
jbe 0x147d2
movq 0x47bc4(%rip), %rdi     # 0x5c310
movq 0x18(%r9), %rcx
testq %rdi, %rdi
je 0x14775
movq (%rcx), %rdx
testb $-0x80, 0xd(%rdx,%r12,4)
jne 0x14775
movq (%rdi), %rax
movl %r14d, %esi
callq *0x60(%rax)
movq -0x30(%rbp), %r9
movq 0x10(%r9), %rax
movq 0x18(%r9), %rcx
movq (%rcx), %rcx
orl $0x8000, 0xc(%rcx,%r12,4) # imm = 0x8000
cmpl $-0x1, -0x40(%rbp)
je 0x14797
cmpl $0x3, -0x3c(%rbp)
jne 0x14797
cmpl %r14d, -0x38(%rbp)
je 0x149d2
cmpl %r14d, 0x10(%rax)
jbe 0x153f5
movq 0x8(%rax), %rcx
movl (%rcx,%r12,4), %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
je 0x14990
cmpl %r14d, 0x8(%rcx,%rdx,4)
je 0x149bd
cmpl %r14d, 0x4(%rcx,%rdx,4)
je 0x149bd
jmp 0x149d2
movq 0x18(%r9), %rcx
movq (%rcx), %rcx
movl 0xc(%rcx,%r12,4), %edx
movl 0xb0(%r9), %esi
testw %dx, %dx
js 0x1492e
cmpl $-0x1, -0x34(%rbp)
je 0x14a0d
cmpl %esi, %r14d
jbe 0x14a0d
movq 0x47b08(%rip), %rdi     # 0x5c310
testq %rdi, %rdi
je 0x1482a
movq (%rdi), %rax
movl %r14d, %esi
callq *0x60(%rax)
movq -0x30(%rbp), %r9
movq 0x10(%r9), %rax
movq 0x18(%r9), %rcx
movq (%rcx), %rcx
movl 0xc(%rcx,%r12,4), %edx
orl $0x8000, %edx           # imm = 0x8000
movl %edx, 0xc(%rcx,%r12,4)
jmp 0x14781
movq 0x10(%r9), %rdx
movl 0x5c(%rdx), %ecx
movl %ecx, -0x40(%rbp)
movl $0xffffffff, -0x44(%rbp) # imm = 0xFFFFFFFF
movl %r13d, %ecx
movl (%r15,%rcx,4), %r12d
shrl %r12d
decl %r12d
cmpl 0x38(%rdx), %r12d
jae 0x14a40
movq 0x30(%rdx), %rcx
movl %r12d, %esi
movl (%rcx,%rsi,4), %ecx
cmpl $-0x1, %ecx
je 0x14a40
movq 0x8(%rdx), %rdx
leaq 0x47a74(%rip), %rsi     # 0x5c2f4
movl (%rsi), %esi
movl %ecx, %r12d
movl %ecx, %edi
leaq (%rdx,%rdi,4), %r8
incl %esi
leaq 0x47a60(%rip), %r9      # 0x5c2f4
movl %esi, (%r9)
movzwl 0xc(%r8), %r9d
andl $0x7fff, %r9d           # imm = 0x7FFF
movzwl (%r15), %r10d
movw $0x7fff, %r11w          # imm = 0x7FFF
andw %r11w, %r10w
je 0x148f0
testw %r9w, %r9w
je 0x148f0
leaq (%rdx,%rdi,4), %r11
addq $0xc, %r11
movzwl %r10w, %ebx
movzwl %r9w, %r14d
movl (%r11,%r14,4), %r14d
cmpl %r14d, (%r15,%rbx,4)
jne 0x14903
leal -0x1(%r10), %ebx
leal -0x1(%r9), %r14d
cmpw $0x1, %r9w
je 0x148f6
movl %r14d, %r9d
cmpw $0x1, %r10w
movl %ebx, %r10d
jne 0x148c0
jmp 0x148f6
movl %r10d, %ebx
movl %r9d, %r14d
cmpw %r14w, %bx
jb 0x14905
jne 0x14917
jmp 0x14bc1
jae 0x14917
movl 0x8(%r8), %ecx
cmpl $-0x1, %ecx
jne 0x14882
jmp 0x14a37
movl 0x4(%r8), %ecx
cmpl $-0x1, %ecx
jne 0x14882
movl $0x2, %edi
jmp 0x14a3c
cmpl %esi, %r14d
je 0x15433
jb 0x14781
movq %r14, -0x50(%rbp)
jbe 0x14a09
movl (%r15), %eax
testw %ax, %ax
js 0x1550c
movl %eax, 0xc(%rcx,%r12,4)
movq 0x479b1(%rip), %rdi     # 0x5c310
testq %rdi, %rdi
je 0x149fa
movq (%rdi), %rax
movq %r15, %rsi
movl %r14d, %edx
movl $0x1, %ecx
callq *0x40(%rax)
movq 0x47990(%rip), %rdi     # 0x5c310
testq %rdi, %rdi
je 0x149fa
movq (%rdi), %rax
movq %r15, %rsi
callq *0x50(%rax)
jmp 0x149fa
leaq (%rcx,%r12,4), %rcx
movl 0xc(%rcx), %edx
movl $0x7fff, %esi           # imm = 0x7FFF
andl %esi, %edx
decl %edx
movl 0x10(%rcx,%rdx,4), %ecx
shrl %ecx
decl %ecx
cmpl 0x38(%rax), %ecx
jae 0x15490
movq 0x30(%rax), %rdx
movl %ecx, %ecx
cmpl %r14d, (%rdx,%rcx,4)
jne 0x149d2
movl 0x5c(%rax), %eax
movl %eax, -0x40(%rbp)
movl $0x3, -0x3c(%rbp)
movl %r14d, -0x38(%rbp)
movl %r14d, -0x44(%rbp)
movq 0x47937(%rip), %rdi     # 0x5c310
testq %rdi, %rdi
je 0x14a00
movq (%rdi), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, -0x50(%rbp)
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
callq *0x40(%rax)
movq -0x30(%rbp), %r9
jmp 0x14a09
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, -0x50(%rbp)
movl %ebx, %edi
jmp 0x14a5b
movzwl 0x2(%r15), %eax
shll $0x10, %eax
orl %edx, %eax
movl %eax, 0xc(%rcx,%r12,4)
movq 0x478ed(%rip), %rdi     # 0x5c310
testq %rdi, %rdi
movq %r14, -0x50(%rbp)
je 0x14a09
movq (%rdi), %rax
movq %r15, %rsi
movl %r14d, %edx
jmp 0x149f2
movl $0x1, %edi
movq -0x30(%rbp), %r9
movl %edi, -0x3c(%rbp)
movl %r12d, -0x38(%rbp)
leaq 0x478a2(%rip), %rax     # 0x5c2f0
incl (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, -0x50(%rbp)
xorl %edi, %edi
movl (%r15), %ebx
movl %ebx, %r14d
shrl $0x10, %r14d
movzwl %di, %eax
movl %eax, %ecx
notl %ecx
testl %ecx, %r14d
je 0x152de
movl %r14d, %ecx
notl %ecx
testl %eax, %ecx
jne 0x152bf
xorl %r12d, %r12d
cmpl $0x4, %r13d
je 0x14b21
cmpl $0x3, %r13d
je 0x14b14
cmpl $0x2, %r13d
jne 0x1535a
cmpl $0x8, %r14d
ja 0x14b85
movl $0x116, %eax            # imm = 0x116
btl %r14d, %eax
jae 0x14b85
movl 0xb0(%r9), %eax
movq -0x50(%rbp), %r14
cmpl %eax, %r14d
movq -0x60(%rbp), %r13
jb 0x15379
movl %eax, %ecx
movl -0x54(%rbp), %esi
xorl %esi, %ecx
movl %r14d, %edx
xorl %esi, %edx
orl %ecx, %edx
je 0x14af3
cmpl $-0x1, %r14d
jne 0x14d0c
cmpl %eax, -0x34(%rbp)
jne 0x14d0c
movq %r9, %rdi
movq %r15, %rsi
movq %r9, %rbx
callq 0x1591c
movl %eax, %r12d
addl $-0x3, %eax
cmpl $0x2, %eax
jae 0x14b67
movl %r12d, %ecx
movq %rbx, %r9
jmp 0x14b49
movq -0x60(%rbp), %r13
movq -0x50(%rbp), %r14
jmp 0x14d0c
movq -0x50(%rbp), %r14
cmpl $-0x1, %r14d
je 0x14b58
movq 0x18(%r9), %rax
movq (%rax), %rax
movl %r14d, %ecx
xorl %r12d, %r12d
testb $-0x80, 0xd(%rax,%rcx,4)
movq -0x60(%rbp), %rax
movl %eax, %ecx
jne 0x153b7
cmpl $-0x1, %r14d
sete %al
movl %ecx, %r13d
jmp 0x14dbd
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movq -0x60(%rbp), %r13
jmp 0x14d0c
movq %rbx, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x12d5e
testl %eax, %eax
movq %rbx, %r9
je 0x14d0c
jmp 0x15452
cmpl $-0x1, -0x50(%rbp)
movq -0x60(%rbp), %r13
je 0x14c16
movq 0x47776(%rip), %rdi     # 0x5c310
testq %rdi, %rdi
je 0x14c02
movq 0x18(%r9), %rax
movq (%rax), %rax
movq -0x50(%rbp), %rsi
movl %esi, %r12d
testb $-0x80, 0xd(%rax,%r12,4)
jne 0x14c06
movq (%rdi), %rax
callq *0x60(%rax)
movq -0x30(%rbp), %r9
jmp 0x14c06
movl $0x3, -0x3c(%rbp)
movq %r12, %r14
movl %r14d, -0x38(%rbp)
movl %r14d, -0x44(%rbp)
cmpl $-0x1, %ecx
movq -0x30(%rbp), %r9
je 0x14a47
leaq 0x47705(%rip), %rdx     # 0x5c2ec
incl (%rdx)
cmpl %eax, %ecx
jae 0x15017
movq 0x18(%r9), %rcx
movq (%rcx), %rcx
movzwl 0xe(%rcx,%rdi,4), %edi
jmp 0x146a9
movl -0x50(%rbp), %r12d
movq 0x18(%r9), %rax
movq (%rax), %rax
orl $0x8000, 0xc(%rax,%r12,4) # imm = 0x8000
movzwl %r14w, %eax
movl $0x4, %r12d
addl $-0x3, %eax
cmpl $0xb, %eax
ja 0x15007
leaq 0x2d169(%rip), %rcx     # 0x41d9c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x4(%r15), %esi
notl %ebx
xorl %edx, %edx
testl $0xa0000, %ebx          # imm = 0xA0000
sete %dl
movq %r9, %rdi
callq 0x15b80
movq -0x30(%rbp), %r9
movl $0x4, %ecx
cmpl $0x4, %eax
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
je 0x14b49
movl (%r15), %eax
movl 0x8(%r15), %esi
notl %eax
xorl %edx, %edx
testl $0xc0000, %eax          # imm = 0xC0000
sete %dl
jmp 0x14cf7
xorl %edx, %edx
cmpl $0xa, %r14d
sete %dl
movl 0x4(%r15), %esi
jmp 0x14cf7
xorl %edx, %edx
cmpl $0xc, %r14d
sete %dl
movl 0x8(%r15), %esi
jmp 0x14cf7
xorl %edx, %edx
cmpl $0x9, %r14d
sete %dl
movq 0xb8(%r9), %rax
movq (%rax), %rax
movl 0x4(%r15), %ecx
movl 0x8(%r15), %esi
movl %esi, %edi
shrl %edi
decl %edi
movl (%rax,%rdi,4), %eax
xorl %ecx, %edx
cmpl $0x1, %eax
ja 0x14cde
cmpl $0x2, %ecx
jb 0x14cde
cmpl $-0x1, %edx
je 0x14cde
movq %r9, %rdi
movl %edx, %esi
movl %eax, %edx
jmp 0x14cfa
movl $0x3, %r12d
movl $0x3, %ecx
cmpl %edx, %eax
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
je 0x14b49
movq %r9, %rdi
callq 0x15b80
movq -0x30(%rbp), %r9
movl %eax, %r12d
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpl $-0x1, %r14d
sete %al
testl %r12d, %r12d
cmovnel %r12d, %r13d
jne 0x14dbd
cmpl $-0x1, %r14d
jne 0x14dbd
testb $-0x80, 0x1(%r15)
jne 0x1533b
cmpl $-0x1, -0x34(%rbp)
je 0x14d51
movq 0x18(%r9), %rax
movq (%rax), %rax
movq -0x68(%rbp), %rcx
testb $-0x80, 0xd(%rax,%rcx,4)
je 0x15398
movq 0x10(%r9), %rdi
movq (%rdi), %rax
leaq -0x44(%rbp), %rsi
movq %r9, %rbx
callq *0x8(%rax)
testb %al, %al
je 0x14e11
movl -0x44(%rbp), %r14d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r14
je 0x1518d
movq -0x30(%rbp), %r9
movq 0x18(%r9), %rax
movq (%rax), %rax
movl 0xc(%rax,%r14,4), %eax
testw %ax, %ax
js 0x15185
movl (%r15), %ecx
notl %ecx
andl %ecx, %eax
cmpl $0x10000, %eax          # imm = 0x10000
jb 0x15185
movq %r13, -0x60(%rbp)
cmpl 0xb0(%r9), %r14d
jne 0x14f50
jmp 0x153d6
leal -0x1(%r12), %ecx
cmpl $0x1, %ecx
ja 0x15148
movq 0x4753e(%rip), %rdi     # 0x5c310
testb %al, %al
jne 0x14f22
testq %rdi, %rdi
je 0x14f0e
movq 0x18(%r9), %rax
movq (%rax), %rax
movl %r14d, %ebx
testb $-0x80, 0xd(%rax,%rbx,4)
jne 0x14f13
movq (%rdi), %rax
movl %r14d, %esi
callq *0x60(%rax)
movq -0x30(%rbp), %r9
movq 0x47504(%rip), %rdi     # 0x5c310
jmp 0x14f13
movq 0x10(%rbx), %rax
movl 0x5c(%rax), %ecx
movl %ecx, -0x40(%rbp)
movl $0xffffffff, -0x44(%rbp) # imm = 0xFFFFFFFF
movl (%r15), %ecx
movl $0x7fff, %edx           # imm = 0x7FFF
andl %edx, %ecx
decl %ecx
movl 0x4(%r15,%rcx,4), %r14d
shrl %r14d
decl %r14d
xorl %edx, %edx
cmpl 0x38(%rax), %r14d
movq %rbx, %r9
jae 0x1506c
movq 0x30(%rax), %rcx
movl %r14d, %esi
movl (%rcx,%rsi,4), %ecx
cmpl $-0x1, %ecx
je 0x1506c
movq 0x8(%rax), %rdx
leaq 0x4748e(%rip), %rsi     # 0x5c2f4
movl (%rsi), %esi
movl %ecx, %r14d
movl %ecx, %r12d
leaq (%rdx,%r12,4), %rdi
incl %esi
leaq 0x47479(%rip), %r8      # 0x5c2f4
movl %esi, (%r8)
movzwl 0xc(%rdi), %r8d
andl $0x7fff, %r8d           # imm = 0x7FFF
movzwl (%r15), %r9d
movw $0x7fff, %r10w          # imm = 0x7FFF
andw %r10w, %r9w
je 0x14ed7
testw %r8w, %r8w
je 0x14ed7
leaq (%rdx,%r12,4), %r10
addq $0xc, %r10
movzwl %r9w, %r11d
movzwl %r8w, %ebx
movl (%r10,%rbx,4), %ebx
cmpl %ebx, (%r15,%r11,4)
jne 0x14eea
leal -0x1(%r9), %r11d
leal -0x1(%r8), %ebx
cmpw $0x1, %r8w
je 0x14edd
movl %ebx, %r8d
cmpw $0x1, %r9w
movl %r11d, %r9d
jne 0x14ea7
jmp 0x14edd
movl %r9d, %r11d
movl %r8d, %ebx
cmpw %bx, %r11w
jb 0x14eec
jne 0x14efd
jmp 0x14f73
jae 0x14efd
movl 0x8(%rdi), %ecx
cmpl $-0x1, %ecx
jne 0x14e68
jmp 0x1505c
movl 0x4(%rdi), %ecx
cmpl $-0x1, %ecx
jne 0x14e68
jmp 0x15063
movl %r14d, %ebx
xorl %edi, %edi
movq 0x18(%r9), %rax
movq (%rax), %rax
orl $0x8000, 0xc(%rax,%rbx,4) # imm = 0x8000
movq %r13, -0x60(%rbp)
testq %rdi, %rdi
je 0x14f4a
movq (%rdi), %rax
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
callq *0x40(%rax)
movq -0x30(%rbp), %r9
jmp 0x14f50
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
incq 0xc8(%r9)
movl (%r15), %eax
movl %eax, %r13d
andl $0x7fff, %r13d          # imm = 0x7FFF
cmpl $0x1, %r13d
ja 0x14687
jmp 0x1501e
movl $0x3, -0x3c(%rbp)
movl %r14d, -0x38(%rbp)
movl %r14d, -0x44(%rbp)
cmpl $-0x1, %ecx
movq -0x30(%rbp), %r9
je 0x15073
leaq 0x47356(%rip), %rdx     # 0x5c2ec
incl (%rdx)
movl -0x34(%rbp), %edi
cmpl %edi, %ecx
je 0x154af
movq 0x18(%r9), %rdx
movq (%rdx), %rdx
movl 0xc(%rdx,%r12,4), %esi
movl %esi, %r8d
shrl $0x10, %r8d
cmpl %ecx, %edi
movq %r13, -0x60(%rbp)
jae 0x14fcf
movzwl 0x2(%r15), %eax
notl %eax
testl %eax, %r8d
jne 0x14f50
jmp 0x1522f
movl 0xb0(%r9), %r9d
movl (%r15), %edi
movl %edi, %r10d
shrl $0x10, %r10d
notl %r8d
cmpl %r9d, %ecx
ja 0x151e6
testl %r8d, %r10d
je 0x151c0
cmpl %r9d, %ecx
movq -0x30(%rbp), %r9
jne 0x14f50
jmp 0x1552b
movl $0x4, %ecx
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x14b49
xorl %edi, %edi
jmp 0x146a9
testl %r13d, %r13d
je 0x15051
shrl $0x10, %eax
cmpl $0x3, %eax
movl $0x4, %r13d
je 0x151c0
movl 0x4(%r15), %esi
xorl %edx, %edx
cmpl $0x2, %eax
sete %dl
movq %r9, %rdi
callq 0x15b80
movl %eax, %r13d
jmp 0x151c0
movl $0x4, %r13d
jmp 0x151c0
movl $0x1, %edx
jmp 0x15068
movl $0x2, %edx
movq -0x30(%rbp), %r9
movl %edx, -0x3c(%rbp)
movl %r14d, -0x38(%rbp)
leaq 0x47276(%rip), %rax     # 0x5c2f0
incl (%rax)
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl -0x34(%rbp), %eax
cmpl -0x44(%rbp), %r14d
jne 0x15414
cmpl $-0x1, %eax
je 0x1519b
cmpl $-0x1, %r14d
je 0x150ff
movq 0x18(%r9), %rax
movq (%rax), %rax
movl %r14d, %ebx
movl 0xc(%rax,%rbx,4), %ecx
testw %cx, %cx
js 0x150ff
cmpl 0xb0(%r9), %r14d
jbe 0x154ce
movl (%r15), %edx
notl %edx
andl %ecx, %edx
cmpl $0x10000, %edx          # imm = 0x10000
jae 0x154ed
movq 0x47238(%rip), %rdi     # 0x5c310
testq %rdi, %rdi
je 0x150f5
movq (%rdi), %rax
movl %r14d, %esi
callq *0x60(%rax)
movq -0x30(%rbp), %r9
movq 0x18(%r9), %rax
movq (%rax), %rax
movl 0xc(%rax,%rbx,4), %ecx
orl $0x8000, %ecx           # imm = 0x8000
movl %ecx, 0xc(%rax,%rbx,4)
movq 0x10(%r9), %rdi
leaq -0x44(%rbp), %rdx
movl -0x34(%rbp), %esi
movq %r9, %rbx
callq 0x1554a
movl (%r15), %eax
testw %ax, %ax
js 0x15471
andl $0x7fff, %eax           # imm = 0x7FFF
leaq 0x4(,%rax,4), %rdx
movq 0x18(%rbx), %rax
movq (%rax), %rax
movq -0x68(%rbp), %rcx
leaq (%rax,%rcx,4), %rdi
addq $0xc, %rdi
movq %r15, %rsi
callq 0xb450
jmp 0x151ab
cmpl $0x3, %r12d
setne %cl
orb %cl, %al
jne 0x151c0
movq 0x471b6(%rip), %rdi     # 0x5c310
testq %rdi, %rdi
je 0x151d2
movq 0x18(%r9), %rax
movq (%rax), %rax
movl %r14d, %ebx
testb $-0x80, 0xd(%rax,%rbx,4)
jne 0x151d5
movq (%rdi), %rax
movl %r14d, %esi
callq *0x60(%rax)
movq -0x30(%rbp), %r9
jmp 0x151d5
movq -0x60(%rbp), %r13
jmp 0x151c0
movl -0x34(%rbp), %eax
jmp 0x1508f
cmpl $-0x1, -0x34(%rbp)
movq -0x30(%rbp), %r9
jne 0x150ff
movq 0x10(%r9), %rdi
leaq -0x44(%rbp), %rdx
movq %r15, %rsi
callq 0x12442
movq 0x4715e(%rip), %rdi     # 0x5c310
testq %rdi, %rdi
je 0x151c0
movq (%rdi), %rax
movq %r15, %rsi
callq *0x50(%rax)
movl %r13d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r14d, %ebx
movq 0x18(%r9), %rax
movq (%rax), %rax
orl $0x8000, 0xc(%rax,%rbx,4) # imm = 0x8000
jmp 0x151c0
testl %r8d, %r10d
je 0x151c0
movl 0x50(%rax), %eax
cmpl $-0x1, %eax
setne %r8b
cmpl %ecx, %eax
seta %al
testb %al, %r8b
jne 0x15271
movl %esi, %eax
andl $0x8000, %eax           # imm = 0x8000
jne 0x15271
andl $0xffff0000, %edi       # imm = 0xFFFF0000
orl %esi, %edi
movl %edi, 0xc(%rdx,%r12,4)
movq 0x470f4(%rip), %rdi     # 0x5c310
testq %rdi, %rdi
je 0x151c0
movq (%rdi), %rax
movq %r15, %rsi
movl %r14d, %edx
callq *0x58(%rax)
jmp 0x151c0
movq 0x470da(%rip), %rdi     # 0x5c310
testq %rdi, %rdi
je 0x1525d
movl %esi, %eax
andl $0x8000, %eax           # imm = 0x8000
jne 0x1525d
movq (%rdi), %rax
movl %r14d, %esi
callq *0x60(%rax)
movq -0x30(%rbp), %r9
movq 0x18(%r9), %rax
movq (%rax), %rdx
movl 0xc(%rdx,%r12,4), %esi
orl $0x8000, %esi           # imm = 0x8000
movl %esi, 0xc(%rdx,%r12,4)
movq -0x60(%rbp), %r13
jmp 0x15082
andl $0xffff0000, %esi       # imm = 0xFFFF0000
orl %esi, %edi
movl %edi, (%r15)
movq 0x4708d(%rip), %rdi     # 0x5c310
testq %rdi, %rdi
je 0x152ad
testb $-0x80, 0xd(%rdx,%r12,4)
movq -0x30(%rbp), %r9
movl -0x34(%rbp), %eax
jne 0x152b4
movq (%rdi), %rax
movl %r14d, %esi
callq *0x60(%rax)
movq -0x30(%rbp), %r9
movq 0x18(%r9), %rax
movq (%rax), %rdx
jmp 0x152b1
movq -0x30(%rbp), %r9
movl -0x34(%rbp), %eax
orb $-0x80, 0xd(%rdx,%r12,4)
jmp 0x15085
leaq 0x2d80f(%rip), %rdi     # 0x42ad5
leaq 0x2cb3b(%rip), %rsi     # 0x41e08
leaq 0x2d741(%rip), %rcx     # 0x42a15
movl $0x1e5, %edx            # imm = 0x1E5
callq 0xb180
leaq 0x2d7d0(%rip), %rdi     # 0x42ab5
leaq 0x2cb1c(%rip), %rsi     # 0x41e08
leaq 0x2d722(%rip), %rcx     # 0x42a15
movl $0x1e3, %edx            # imm = 0x1E3
callq 0xb180
leaq 0x2d788(%rip), %rdi     # 0x42a8c
leaq 0x2cafd(%rip), %rsi     # 0x41e08
leaq 0x2d703(%rip), %rcx     # 0x42a15
movl $0x1b4, %edx            # imm = 0x1B4
callq 0xb180
leaq 0x2d6a9(%rip), %rdi     # 0x429cc
leaq 0x2cade(%rip), %rsi     # 0x41e08
leaq 0x2d6e4(%rip), %rcx     # 0x42a15
movl $0x18b, %edx            # imm = 0x18B
callq 0xb180
leaq 0x2c063(%rip), %rdi     # 0x413a5
leaq 0x2cabf(%rip), %rsi     # 0x41e08
leaq 0x2d6c5(%rip), %rcx     # 0x42a15
movl $0x22a, %edx            # imm = 0x22A
callq 0xb180
leaq 0x32941(%rip), %rdi     # 0x47ca2
leaq 0x2caa0(%rip), %rsi     # 0x41e08
leaq 0x2d6a6(%rip), %rcx     # 0x42a15
movl $0x223, %edx            # imm = 0x223
callq 0xb180
leaq 0x2d775(%rip), %rdi     # 0x42af5
leaq 0x2ca81(%rip), %rsi     # 0x41e08
leaq 0x2d687(%rip), %rcx     # 0x42a15
movl $0x1ed, %edx            # imm = 0x1ED
callq 0xb180
leaq 0x2d81c(%rip), %rdi     # 0x42bbb
leaq 0x2ca62(%rip), %rsi     # 0x41e08
leaq 0x2d668(%rip), %rcx     # 0x42a15
movl $0x22c, %edx            # imm = 0x22C
callq 0xb180
leaq 0x2d7c7(%rip), %rdi     # 0x42b85
leaq 0x2ca43(%rip), %rsi     # 0x41e08
leaq 0x2d649(%rip), %rcx     # 0x42a15
movl $0x221, %edx            # imm = 0x221
callq 0xb180
leaq 0x2d6bc(%rip), %rdi     # 0x42a99
leaq 0x2ca24(%rip), %rsi     # 0x41e08
leaq 0x2d62a(%rip), %rcx     # 0x42a15
movl $0x266, %edx            # imm = 0x266
callq 0xb180
leaq 0x2c540(%rip), %rdi     # 0x4193c
leaq 0x2c32a(%rip), %rsi     # 0x4172d
leaq 0x2d8ef(%rip), %rcx     # 0x42cf9
movl $0x1ea, %edx            # imm = 0x1EA
callq 0xb180
leaq 0x2d822(%rip), %rdi     # 0x42c3d
leaq 0x2c9e6(%rip), %rsi     # 0x41e08
leaq 0x2d5ec(%rip), %rcx     # 0x42a15
movl $0x25f, %edx            # imm = 0x25F
callq 0xb180
leaq 0x2d65f(%rip), %rdi     # 0x42a99
leaq 0x2c9c7(%rip), %rsi     # 0x41e08
leaq 0x2d5cd(%rip), %rcx     # 0x42a15
movl $0x1c0, %edx            # imm = 0x1C0
callq 0xb180
leaq 0x2d6b8(%rip), %rdi     # 0x42b11
leaq 0x2c9a8(%rip), %rsi     # 0x41e08
leaq 0x2d5ae(%rip), %rcx     # 0x42a15
movl $0x1f1, %edx            # imm = 0x1F1
callq 0xb180
leaq 0x2bf2d(%rip), %rdi     # 0x413a5
leaq 0x2c989(%rip), %rsi     # 0x41e08
leaq 0x2d58f(%rip), %rcx     # 0x42a15
movl $0x279, %edx            # imm = 0x279
callq 0xb180
leaq 0x2c88a(%rip), %rdi     # 0x41d21
leaq 0x2c28f(%rip), %rsi     # 0x4172d
leaq 0x2d854(%rip), %rcx     # 0x42cf9
movl $0x1f3, %edx            # imm = 0x1F3
callq 0xb180
leaq 0x2d76f(%rip), %rdi     # 0x42c25
leaq 0x2c94b(%rip), %rsi     # 0x41e08
leaq 0x2d551(%rip), %rcx     # 0x42a15
movl $0x232, %edx            # imm = 0x232
callq 0xb180
leaq 0x2d793(%rip), %rdi     # 0x42c68
leaq 0x2c92c(%rip), %rsi     # 0x41e08
leaq 0x2d532(%rip), %rcx     # 0x42a15
movl $0x271, %edx            # imm = 0x271
callq 0xb180
leaq 0x2d78f(%rip), %rdi     # 0x42c83
leaq 0x2c90d(%rip), %rsi     # 0x41e08
leaq 0x2d513(%rip), %rcx     # 0x42a15
movl $0x272, %edx            # imm = 0x272
callq 0xb180
leaq 0x2be92(%rip), %rdi     # 0x413a5
leaq 0x2c8ee(%rip), %rsi     # 0x41e08
leaq 0x2d4f4(%rip), %rcx     # 0x42a15
movl $0x1c9, %edx            # imm = 0x1C9
callq 0xb180
leaq 0x2d567(%rip), %rdi     # 0x42a99
leaq 0x2c8cf(%rip), %rsi     # 0x41e08
leaq 0x2d4d5(%rip), %rcx     # 0x42a15
movl $0x248, %edx            # imm = 0x248
callq 0xb180