LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/seq_io/read_fasta_fastq.h
// Function: bool seqan::guessStreamFormat<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>(seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>&, seqan::Tag<seqan::TagFastq_> const&)
inline bool
guessStreamFormat(RecordReader<TStream, TPass> & reader, Fastq const & /*tag*/)
{
    LimitRecordReaderInScope<TStream, TPass> limiter(reader);
    while (!atEnd(reader))
    {
        CharString meta;
        CharString seq;
        CharString qual;
        int r = readRecord(meta, seq, qual, reader, Fastq());
        if (r == RecordReader<TStream, TPass>::INVALID_FORMAT)
            return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq 0x8(%rdi), %rcx
movq %rdi, -0x38(%rbp)
movq 0x10(%rdi), %rax
movq %rax, -0x40(%rbp)
subq %rcx, %rax
cmpq $0x2001, %rax           # imm = 0x2001
jl 0xb5d3
leaq 0x2000(%rcx), %rax
movq -0x38(%rbp), %rdx
movq %rax, 0x10(%rdx)
movq %rcx, -0x48(%rbp)
leaq -0x90(%rbp), %r13
leaq -0x78(%rbp), %r12
movq -0x38(%rbp), %rax
movq 0x8(%rax), %r14
movq 0x10(%rax), %r15
cmpq %r15, %r14
je 0xb653
movq %r13, %rdi
callq 0x6e2e
leaq -0x60(%rbp), %rdi
callq 0x6e2e
movq %r12, %rdi
callq 0x6e2e
movq %r12, %rdx
movq %r13, %rbx
movq %r13, %rdi
leaq -0x60(%rbp), %rsi
movq %rdx, %r12
movq -0x38(%rbp), %rcx
leaq -0x29(%rbp), %r8
callq 0xb6fa
movl %eax, %r13d
movq -0x78(%rbp), %rdi
callq 0x32e0
movq -0x60(%rbp), %rdi
callq 0x32e0
movq -0x90(%rbp), %rdi
callq 0x32e0
cmpl $0x1, %r13d
movq %rbx, %r13
jne 0xb5e2
cmpq %r15, %r14
sete %al
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdx
movq %rcx, 0x10(%rdx)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rdx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xb6a0
movq %rax, %r14
movq -0x78(%rbp), %rdi
callq 0x32e0
jmp 0xb697
movq %rax, %r14
jmp 0xb6ac
movq %rax, %r14
movq -0x60(%rbp), %rdi
callq 0x32e0
movq -0x90(%rbp), %rdi
callq 0x32e0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rax, 0x10(%rcx)
movq -0x48(%rbp), %rax
movq %rax, 0x8(%rcx)
movq %r14, %rdi
callq 0x3590
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/seq_io/read_fasta_fastq.h
// Function: int seqan::readRecord<seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>(seqan::String<char, seqan::Alloc<void>>&, seqan::String<char, seqan::Alloc<void>>&, seqan::String<char, seqan::Alloc<void>>&, seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>&, seqan::Tag<seqan::TagFastq_> const&)
inline int
readRecord(TIdString & meta,
           TSeqString & seq,
           TQualString & qual,
           RecordReader<TFile, TPass > & reader,
           Fastq const & /*tag*/)
{
    int res = _clearAndReserveMemory(meta, seq, qual, reader, Fastq());
    if (res)
        return res;

    res = _readMetaAndSequence(meta, seq, reader, Fastq());
    if (res)
        return res;

    res = _readQualityBlock(qual, reader, length(seq), meta, Fastq());
    if (res == 0 || res == EOF_BEFORE_SUCCESS)
        return 0;
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq -0x23(%rbp), %r8
callq 0xb76a
testl %eax, %eax
jne 0xb75d
leaq -0x22(%rbp), %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xb793
testl %eax, %eax
jne 0xb75d
movl 0x8(%r12), %edx
subl (%r12), %edx
leaq -0x21(%rbp), %r8
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0xb82c
movl %eax, %ecx
andl $0xfffffbff, %eax       # imm = 0xFFFFFBFF
cmovnel %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/seq_io/read_fasta_fastq.h
// Function: int seqan::_clearAndReserveMemory<seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>, seqan::Tag<seqan::TagFastq_>>(seqan::String<char, seqan::Alloc<void>>&, seqan::String<char, seqan::Alloc<void>>&, seqan::String<char, seqan::Alloc<void>>&, seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>&, seqan::Tag<seqan::TagFastq_> const&)
inline int
_clearAndReserveMemory(TIdString & meta, TSeqString & seq, TQualString & qual,
                       RecordReader<TFile, TSpec> & reader,
                       TTag const & tag)
{
    int res = _clearAndReserveMemory(meta, seq, reader, tag);
    clear(qual);
    reserve(qual, capacity(seq), Exact());
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq %rax, 0x8(%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rsi)
movq (%rdx), %rax
movq %rax, 0x8(%rdx)
movq 0x10(%rsi), %rsi
movq %rdx, %rdi
callq 0xab81
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/seq_io/read_fasta_fastq.h
// Function: int seqan::_readMetaAndSequence<seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>, seqan::Tag<seqan::TagFastq_>>(seqan::String<char, seqan::Alloc<void>>&, seqan::String<char, seqan::Alloc<void>>&, seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>&, seqan::Tag<seqan::TagFastq_> const&)
inline int
_readMetaAndSequence(TIdString & meta, TSeqString & seq,
                     RecordReader<TFile, TPass > & reader,
                     TTag const & formatTag)
{
    // READ META
    if (atEnd(reader) || value(reader) != MetaFirstChar_<TTag>::VALUE)
        return RecordReader<TFile, TPass>::INVALID_FORMAT;
    goNext(reader);
    if (resultCode(reader))
        return resultCode(reader);
    if (atEnd(reader)) // empty ID, no sequence, this is legal
        return 0;

    int res = readLine(meta, reader);
    if (res == EOF_BEFORE_SUCCESS)
        return EOF_BEFORE_SUCCESS;
    else if (res)
        return res;

    if (atEnd(reader)) // no sequence
        return 0;

    // READ SEQUENCE
    res = _readSequenceFastAQ(seq, reader, formatTag);
    if (res && res != EOF_BEFORE_SUCCESS)
        return res;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdx), %rax
pushq $0x1
popq %r12
cmpq 0x10(%rdx), %rax
je 0xb81a
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq %rdx, %rdi
callq 0xb3d7
cmpb $0x40, %al
jne 0xb81a
movq %r14, %rdi
callq 0xb41d
movq 0x8(%r14), %rax
xorl %r12d, %r12d
cmpq 0x10(%r14), %rax
je 0xb81a
movq %r13, %rdi
movq %r14, %rsi
callq 0xb4b6
movl %eax, %r12d
testl %eax, %eax
jne 0xb81a
movq 0x8(%r14), %rax
movl $0x0, %r12d
cmpq 0x10(%r14), %rax
je 0xb81a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xb943
movl %eax, %r12d
andl $0xfffffbff, %r12d      # imm = 0xFFFFFBFF
cmovnel %eax, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/seq_io/read_fasta_fastq.h
// Function: int seqan::_readSequenceFastAQCharImpl<seqan::String<char, seqan::Alloc<void>>, seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>, seqan::Tag<seqan::TagFastq_>>(seqan::String<char, seqan::Alloc<void>>&, seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>&, seqan::Tag<seqan::TagFastq_> const&)
inline int
_readSequenceFastAQCharImpl(TString & string,
                            TRecordReader & reader,
                            TFormatTag const & /*formatTag*/)
{
    // The variable afterEol is true if we are after an EOL char and we are not at the beginning of the sequence
    // record.  Empty sequence lines are fine, non-existent ones are not.
    bool afterEol = false;

    while (!atEnd(reader))
    {
        char c = value(reader);
        if (c == '\r' || c == '\n')
        {
            afterEol = true;
            goNext(reader);
            if (resultCode(reader) != 0)
                return resultCode(reader);
            continue;
        }

        if (afterEol && c == AfterSeqFirstChar_<TFormatTag>::VALUE)
        {
            return 0;  // Done, at stop char.
        }

        if (!isspace(c))
            appendValue(string, c);
        afterEol = false;
        goNext(reader);
        if (resultCode(reader) != 0)
            return resultCode(reader);
    }

    return EOF_BEFORE_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq -0x29(%rbp), %r15
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0xb9ba
movq %rbx, %rdi
callq 0xb3d7
movb %al, -0x29(%rbp)
movb $0x1, %r13b
cmpb $0xa, %al
je 0xb9ad
movzbl %al, %ecx
cmpl $0xd, %ecx
je 0xb9ad
cmpb $0x2b, %al
setne %cl
notb %r12b
orb %cl, %r12b
testb $0x1, %r12b
je 0xb9c1
movsbl %al, %edi
callq 0x3070
testl %eax, %eax
jne 0xb9aa
movq %r14, %rdi
movq %r15, %rsi
callq 0xa528
xorl %r13d, %r13d
movq %rbx, %rdi
callq 0xb41d
movl %r13d, %r12d
jmp 0xb95e
movl $0x400, %eax            # imm = 0x400
jmp 0xb9c3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/sequence/sequence_lexical.h
// Function: void seqan::compare_<unsigned long, seqan::String<char, seqan::Alloc<void>> const, char const*>(seqan::Lexical<unsigned long>&, seqan::String<char, seqan::Alloc<void>> const&, char const*&)
inline void
compare_(Lexical<TSpec> & lexical,
		 TLeft & left,
		 TRight & right)
{
	typename Iterator<TLeft, Standard>::Type left_it = begin(left, Standard());
	typename Size<TLeft>::Type left_length = length(left);
	typename Iterator<TRight, Standard>::Type right_it = begin(right, Standard());
	typename Size<TRight>::Type right_length = length(right);

	if (left_length == right_length) lexical.data_compare = Lexical<TSpec>::EQUAL;
	else if (left_length < right_length) lexical.data_compare = Lexical<TSpec>::LEFT_IS_PREFIX;
	else
	{
		lexical.data_compare = Lexical<TSpec>::RIGHT_IS_PREFIX;
		left_length = right_length;
	}

	lexical.data_lcp = 0;
	for (lexical.data_lcp = 0; lexical.data_lcp < left_length; ++lexical.data_lcp)
	{
		if (*left_it < *right_it)
		{
			lexical.data_compare = Lexical<TSpec>::LESS;
			break;
		}
		if (*left_it > *right_it)
		{
			lexical.data_compare = Lexical<TSpec>::GREATER;
			break;
		}
		++left_it;
		++right_it;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r12
subq %r15, %r12
movq (%rdx), %r14
movq %r14, %rdi
callq 0x3170
cmpq %rax, %r12
jne 0xba9f
movb $0x1, 0x8(%rbx)
jmp 0xbaae
jae 0xbaa7
movb $0x8, 0x8(%rbx)
jmp 0xbaae
movb $0x10, 0x8(%rbx)
movq %rax, %r12
xorl %eax, %eax
movq %rax, (%rbx)
cmpq %rax, %r12
je 0xbad2
movb (%r14,%rax), %cl
cmpb %cl, (%r15,%rax)
jl 0xbac9
jg 0xbacd
incq %rax
jmp 0xbab0
movb $0x2, %al
jmp 0xbacf
movb $0x4, %al
movb %al, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/stream/tokenize.h
// Function: int seqan::_readNCharsIgnoringType<seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>, seqan::Tag<seqan::Whitespace__>>(seqan::String<char, seqan::Alloc<void>>&, seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>&, unsigned int, seqan::Tag<seqan::Whitespace__>)
inline int
_readNCharsIgnoringType(TBuffer & buffer,
                         RecordReader<TStream, TPass> & reader,
                         unsigned const n,
                         TIgnoredType /* tag */)
{
    SEQAN_CHECKPOINT


    reserve(buffer, n, Exact());

    for (unsigned i = 0; i < n; ++i)
    {
        if (atEnd(reader))
            return EOF_BEFORE_SUCCESS;

        if (_charCompare(value(reader), TIgnoredType()))
            --i;
        else
            appendValue(buffer, value(reader));

        goNext(reader);
        if (resultCode(reader) != 0)
            return resultCode(reader);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r12
movl %edx, %esi
callq 0xbadb
leaq -0x29(%rbp), %r13
xorl %r14d, %r14d
cmpl %ebx, %r14d
jae 0xbc09
movq 0x8(%r15), %rax
cmpq 0x10(%r15), %rax
je 0xbc0d
movq %r15, %rdi
callq 0xb3d7
movsbl %al, %edi
callq 0x3070
testl %eax, %eax
jne 0xbbff
movq %r15, %rdi
callq 0xb3d7
movb %al, -0x29(%rbp)
movq %r12, %rdi
movq %r13, %rsi
callq 0xa528
incl %r14d
movq %r15, %rdi
callq 0xb41d
jmp 0xbbc3
xorl %eax, %eax
jmp 0xbc12
movl $0x400, %eax            # imm = 0x400
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/seq_io/read_fasta_fastq.h
// Function: bool seqan::guessStreamFormat<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>(seqan::RecordReader<seqan::String<char, seqan::MMap<seqan::MMapConfig<seqan::File<seqan::Async<void>>, unsigned long>>>, seqan::SinglePass<seqan::Tag<seqan::StringReader_>>>&, seqan::Tag<seqan::TagFasta_> const&)
inline bool
guessStreamFormat(RecordReader<TStream, TPass> & reader, Fasta const & /*tag*/)
{
    LimitRecordReaderInScope<TStream, TPass> limiter(reader);
    while (!atEnd(reader))
    {
        CharString meta;
        CharString seq;
        int r = readRecord(meta, seq, reader, Fasta());
//         std::cout << "Meta: " << toCString(meta) << "\nSeq: " << toCString(seq) << "\n";
        if (r == RecordReader<TStream, TPass>::INVALID_FORMAT)
            return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x8(%rdi), %rcx
movq %rdi, -0x38(%rbp)
movq 0x10(%rdi), %rax
movq %rax, -0x40(%rbp)
subq %rcx, %rax
cmpq $0x2001, %rax           # imm = 0x2001
jl 0xbc5c
leaq 0x2000(%rcx), %rax
movq -0x38(%rbp), %rdx
movq %rax, 0x10(%rdx)
movq %rcx, -0x48(%rbp)
leaq -0x78(%rbp), %r13
leaq -0x60(%rbp), %r15
movq -0x38(%rbp), %rax
movq 0x8(%rax), %r12
movq 0x10(%rax), %r14
cmpq %r14, %r12
je 0xbcbd
movq %r13, %rdi
callq 0x6e2e
movq %r15, %rdi
callq 0x6e2e
movq %r15, %rsi
movq %r13, %rbx
movq %r13, %rdi
movq -0x38(%rbp), %rdx
leaq -0x29(%rbp), %rcx
callq 0xbd21
movl %eax, %r13d
movq -0x60(%rbp), %rdi
callq 0x32e0
movq -0x78(%rbp), %rdi
callq 0x32e0
cmpl $0x1, %r13d
movq %rbx, %r13
jne 0xbc68
cmpq %r14, %r12
sete %al
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdx
movq %rcx, 0x10(%rdx)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rdx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xbd05
movq %rax, %r14
movq -0x60(%rbp), %rdi
callq 0x32e0
jmp 0xbcfc
movq %rax, %r14
movq -0x78(%rbp), %rdi
callq 0x32e0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rax, 0x10(%rcx)
movq -0x48(%rbp), %rax
movq %rax, 0x8(%rcx)
movq %r14, %rdi
callq 0x3590
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/seq_io/fai_index.h
// Function: seqan::write(seqan::FaiIndex const&, char const*)
inline int write(FaiIndex const & index, char const * faiFilename)
{
    // Open index files.
    std::ofstream indexOut(faiFilename, std::ios::binary | std::ios::out);

    for (unsigned i = 0; i < length(index.indexEntryStore); ++i)
    {
        FaiIndexEntry_ const & entry = index.indexEntryStore[i];
        indexOut << entry.name << '\t' << entry.sequenceLength << '\t' << entry.offset << '\t'
                 << entry.lineLength << '\t' << entry.overallLineLength << '\n';
    }

    return !indexOut.good();  // 1 on errors, 0 on success.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq -0x228(%rbp), %rdi
pushq $0x14
popq %rdx
callq 0x3370
leaq 0x30(%rbx), %r15
xorl %r12d, %r12d
pushq $0x9
popq %r13
movq 0x38(%rbx), %rax
subq 0x30(%rbx), %rax
cqto
pushq $0x30
popq %rcx
idivq %rcx
movl %r12d, %ecx
cmpq %rcx, %rax
jbe 0xc045
movq %r15, %rdi
movl %r12d, %esi
callq 0xc090
movq %rax, %r14
leaq -0x228(%rbp), %rdi
movq %rax, %rsi
callq 0xc127
leaq -0x228(%rbp), %rdi
movl %r13d, %esi
callq 0x3390
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
movl %r13d, %esi
callq 0x3390
movq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
movl %r13d, %esi
callq 0x3390
movl 0x28(%r14), %esi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
movl %r13d, %esi
callq 0x3390
movl 0x2c(%r14), %esi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
pushq $0xa
popq %rsi
callq 0x3390
incl %r12d
jmp 0xbf99
leaq -0x228(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
xorl %ebx, %ebx
cmpl $0x0, -0x208(%rbp,%rax)
setne %bl
callq 0x3490
movl %ebx, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x3490
movq %rbx, %rdi
callq 0x3590
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/sequence/string_base.h
// Function: seqan::Reference<seqan::String<seqan::FaiIndexEntry_, seqan::Alloc<void>> const>::Type seqan::value<seqan::FaiIndexEntry_, seqan::Alloc<void>, unsigned int>(seqan::String<seqan::FaiIndexEntry_, seqan::Alloc<void>> const&, unsigned int const&)
SEQAN_HOST_DEVICE inline typename Reference< String<TValue, TSpec> const >::Type
value(String<TValue, TSpec> const & me,
      TPos const & pos)
{
    SEQAN_CHECKPOINT;
    typedef typename Position< String<TValue, TSpec> const >::Type TStringPos SEQAN_TYPEDEF_FOR_DEBUG;
    SEQAN_ASSERT_LT_MSG(static_cast<TStringPos>(pos), static_cast<TStringPos>(length(me)), "Trying to access an element behind the last one!");
    return *(begin(me, Standard()) + pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leaq -0x20(%rbp), %r10
movq %rax, (%r10)
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x30
popq %rcx
cqto
idivq %rcx
leaq -0x18(%rbp), %r8
movq %rax, (%r8)
leaq 0x12aa(%rip), %rax      # 0xd38d
movq %rax, (%rsp)
leaq 0x1239(%rip), %rdi      # 0xd327
leaq 0x1257(%rip), %rcx      # 0xd34c
leaq 0x126d(%rip), %r9       # 0xd369
movl $0x1fd, %esi            # imm = 0x1FD
movq %r10, %rdx
xorl %eax, %eax
callq 0x7c20
testb %al, %al
je 0xc122
movl (%r14), %eax
imulq $0x30, %rax, %rax
addq (%rbx), %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x31f0
// File: /workspace/github_cpp_makefile_star2_O2/mshabbirhasan[P]ups-indel/include/seqan/sequence/string_base.h
// Function: seqan::Size<seqan::String<seqan::SimpleType<unsigned char, seqan::Dna5_>, seqan::Alloc<void>>>::Type seqan::_Resize_String<seqan::Tag<seqan::TagGenerous_>>::resize_<seqan::String<seqan::SimpleType<unsigned char, seqan::Dna5_>, seqan::Alloc<void>>, seqan::SimpleType<unsigned char, seqan::Dna5_>>(seqan::String<seqan::SimpleType<unsigned char, seqan::Dna5_>, seqan::Alloc<void>>&, seqan::Size<seqan::String<seqan::SimpleType<unsigned char, seqan::Dna5_>, seqan::Alloc<void>>>::Type, seqan::SimpleType<unsigned char, seqan::Dna5_> const&)
static inline typename Size<T>::Type
    resize_(
        T & me,
        typename Size<T>::Type new_length,
        TValue const & val)
    {
        typedef typename Size<T>::Type TSize;
        TSize me_length = length(me);
        if (new_length < me_length)
        {
            SEQAN_CHECKPOINT;
            arrayDestruct(begin(me, Standard()) + new_length, begin(me, Standard()) + me_length);
        }
        else
        {
            TSize me_capacity = capacity(me);
            if (new_length > me_capacity)
            {
                SEQAN_CHECKPOINT;
                TValue tempCopy = val;  // reserve could invalidate val
                TSize new_capacity = reserve(me, new_length, TExpand());
                if (new_capacity < new_length)
                {
                    new_length = new_capacity;
                }
                arrayConstruct(begin(me, Standard()) + me_length, begin(me, Standard()) + new_length, tempCopy);
            } else
                if (new_length > me_length)
                {
                    SEQAN_CHECKPOINT;
                    arrayConstruct(begin(me, Standard()) + me_length, begin(me, Standard()) + new_length, val);
                }
        }

        _setLength(me, new_length);
        return new_length;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rsi
movq 0x8(%rdi), %r15
subq %rsi, %r15
cmpq %rbx, %r15
ja 0xcc30
cmpq %rbx, 0x10(%r14)
jae 0xcc1d
movb (%rdx), %al
leaq -0x21(%rbp), %r12
movb %al, (%r12)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcc4a
cmpq %rbx, %rax
cmovbq %rax, %rbx
movq (%r14), %rsi
addq %rsi, %r15
addq %rbx, %rsi
movq %r15, %rdi
movq %r12, %rdx
jmp 0xcc2b
cmpq %rbx, %r15
jae 0xcc30
addq %rsi, %r15
addq %rbx, %rsi
movq %r15, %rdi
callq 0xcd12
movq (%r14), %rax
addq %rbx, %rax
movq %rax, 0x8(%r14)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/interactive_deduction.tab.cpp
// Function: yy_stack_print(signed char*, signed char*)
static void
yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
{
  YYFPRINTF (stderr, "Stack now");
  for (; yybottom <= yytop; yybottom++)
    {
      int yybot = *yybottom;
      YYFPRINTF (stderr, " %d", yybot);
    }
  YYFPRINTF (stderr, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xc280(%rip), %r12      # 0xffa8
movq (%r12), %rcx
leaq 0x5952(%rip), %rdi      # 0x9685
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
callq 0x32f0
leaq 0x594a(%rip), %r15      # 0x968f
cmpq %rbx, %r14
ja 0x3d61
movsbl (%r14), %edx
movq (%r12), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3200
incq %r14
jmp 0x3d45
movq (%r12), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x31c0
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/interactive_deduction.tab.cpp
// Function: yy_symbol_print(_IO_FILE*, yysymbol_kind_t, YYSTYPE const*, std::shared_ptr<BaseFormula>&)
static void
yy_symbol_print (FILE *yyo,
                 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, Formula & formula)
{
  YYFPRINTF (yyo, "%s %s (",
             yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));

  yy_symbol_value_print (yyo, yykind, yyvaluep, formula);
  YYFPRINTF (yyo, ")");
}

// Assembly:
pushq %rbx
cmpl $0xf, %esi
leaq 0x5989(%rip), %rax      # 0x970c
leaq 0x5911(%rip), %rdx      # 0x969b
cmovlq %rax, %rdx
movq %rdi, %rbx
movslq %esi, %rax
leaq 0xb835(%rip), %rcx      # 0xf5d0
movq (%rcx,%rax,8), %rcx
leaq 0x58ed(%rip), %rsi      # 0x9693
xorl %eax, %eax
callq 0x3200
pushq $0x29
popq %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x31c0
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/formula.cpp
// Function: Atom::equalTo(std::shared_ptr<BaseFormula> const&) const
bool Atom::equalTo(const Formula & f) const {
  if(f->getType() != T_ATOM)
    return false;

  Atom * a = (Atom *) f.get();
  
  return a->getVariable() == _v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x2, %eax
jne 0x746b
movq (%r14), %rdi
addq $0x18, %rdi
addq $0x18, %rbx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x75c4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/formula.cpp
// Function: BinaryConnective::equalTo(std::shared_ptr<BaseFormula> const&) const
bool BinaryConnective::equalTo(const Formula & f) const {
  if(f->getType() != getType())
    return false;

  BinaryConnective * bc = (BinaryConnective *) f.get();
  
  return bc->getOperand1()->equalTo(_op1) &&
          bc->getOperand2()->equalTo(_op2);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpl %eax, %ebp
jne 0x7505
movq (%r14), %r14
movq 0x18(%r14), %rdi
leaq 0x18(%rbx), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x7505
movq 0x28(%r14), %rdi
addq $0x28, %rbx
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: addAssumption(std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>&, std::shared_ptr<BaseFormula> const&)
void addAssumption(vector<Formula> & assumptions, const Formula & f) {
  bool shouldAdd = true; // indicator for whether or not f should be added to assumptions
  for(unsigned i = 0; i < assumptions.size(); i++)
    if(f->equalTo(assumptions[i]))
      shouldAdd = false;
  if(shouldAdd)
    assumptions.push_back(f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movb $0x1, %bpl
movl %eax, %r15d
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x4, %rax
cmpq %r15, %rax
jbe 0x7976
movq (%rbx), %rdi
movq %r15, %rax
shlq $0x4, %rax
addq %rax, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
xorb $0x1, %al
andb %al, %bpl
leal 0x1(%r15), %eax
jmp 0x7942
testb $0x1, %bpl
je 0x7991
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x879c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyAssumption(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>> const&)
bool applyAssumption(const Goal & g) {
  for(Formula a : g.first)
    if(g.second->equalTo(a))
      return true;

  cerr << "Failed to apply Assumption" << endl;
  return false; 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movq (%rdi), %rax
movq 0x8(%rdi), %r13
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r12
movq %rax, %rbx
cmpq %r13, %rax
je 0x79f3
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4c7c
movq 0x18(%r15), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x10(%rax)
movl %eax, %ebp
movq %r14, %rdi
callq 0x4a2e
leaq 0x10(%rbx), %rax
testb %bpl, %bpl
je 0x79be
jmp 0x7a0e
movq 0x85e6(%rip), %rdi      # 0xffe0
leaq 0x2633(%rip), %rsi      # 0xa034
callq 0x3160
movq %rax, %rdi
callq 0x30c0
cmpq %r13, %rbx
setne %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x4a2e
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyNotI(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>&)
void applyNotI(Goal & g) {
  if(g.second->getType() == T_NOT) {
    Formula notOp = ((Not *)g.second.get())->getOperand();

    addAssumption(g.first, notOp);

    g.second = make_shared<False>();
  }
  else
    cerr << "Failed to apply NotI" << endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x7aa9
movq 0x18(%rbx), %rdi
callq 0x7214
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x4c7c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7930
leaq 0x8(%rsp), %rdi
callq 0x47e8
addq $0x18, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8a68
leaq 0x10(%rsp), %rdi
callq 0x4a2e
leaq 0x20(%rsp), %rdi
callq 0x4a2e
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x8530(%rip), %rdi      # 0xffe0
leaq 0x2598(%rip), %rsi      # 0xa04f
callq 0x3160
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x30c0
jmp 0x7acd
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4a2e
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyConjI(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>> const&, std::vector<std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>, std::allocator<std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>>>&)
void applyConjI(const Goal & g, vector<Goal> & subgoals) {
  if(g.second->getType() == T_AND) {
    Goal goal1, goal2;

    goal1.first = g.first;
    goal1.second = ((And *)g.second.get())->getOperand1();

    goal2.first = g.first;
    goal2.second = ((And *)g.second.get())->getOperand2();

    subgoals.push_back(goal1);
    subgoals.push_back(goal2);
  }
  else
    cerr << "Failed to apply ConjI" << endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x4, %eax
jne 0x7b95
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
andq $0x0, 0x20(%rdi)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
andq $0x0, 0x20(%rsp)
movq %r14, %rsi
callq 0x87c8
movq 0x18(%r14), %rdi
callq 0x721a
leaq 0x48(%rsp), %rdi
movq %rax, %rsi
callq 0x4950
movq %rsp, %rdi
movq %r14, %rsi
callq 0x87c8
movq 0x18(%r14), %rdi
callq 0x7220
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x4950
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x8892
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8892
movq %rsp, %rdi
callq 0x4892
leaq 0x30(%rsp), %rdi
callq 0x4892
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq 0x8444(%rip), %rdi      # 0xffe0
leaq 0x24c1(%rip), %rsi      # 0xa064
callq 0x3160
movq %rax, %rdi
addq $0x58, %rsp
popq %rbx
popq %r14
jmp 0x30c0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4892
leaq 0x30(%rsp), %rdi
callq 0x4892
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyDisjI1(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>&)
void applyDisjI1(Goal & g) {
  if(g.second->getType() == T_OR)
    g.second = (((Or *)g.second.get())->getOperand1());
  else
    cerr << "Failed to apply DisjI1" << endl;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x5, %eax
jne 0x7bfe
addq $0x18, %rbx
movq (%rbx), %rdi
callq 0x721a
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x4950
movq 0x83db(%rip), %rdi      # 0xffe0
leaq 0x246e(%rip), %rsi      # 0xa07a
callq 0x3160
movq %rax, %rdi
popq %rbx
jmp 0x30c0
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyDisjI2(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>&)
void applyDisjI2(Goal & g) {
  if(g.second->getType() == T_OR)
    g.second = (((Or *)g.second.get())->getOperand2());
  else
    cerr << "Failed to apply DisjI2" << endl;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x5, %eax
jne 0x7c44
addq $0x18, %rbx
movq (%rbx), %rdi
callq 0x7220
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x4950
movq 0x8395(%rip), %rdi      # 0xffe0
leaq 0x243f(%rip), %rsi      # 0xa091
callq 0x3160
movq %rax, %rdi
popq %rbx
jmp 0x30c0
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyImpI(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>&)
void applyImpI(Goal & g) {
  if(g.second->getType() == T_IMP) {
    Formula a = (((Imp *)g.second.get())->getOperand1());
    Formula b = (((Imp *)g.second.get())->getOperand2());

    addAssumption(g.first, a);

    g.second = b;
  }
  else
    cerr << "Failed to apply ImpI" << endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x6, %eax
jne 0x7cdc
leaq 0x18(%rbx), %r14
movq (%r14), %rdi
callq 0x721a
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x4c7c
movq (%r14), %rdi
callq 0x7220
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x4c7c
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x7930
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x4950
leaq 0x10(%rsp), %rdi
callq 0x4a2e
leaq 0x20(%rsp), %rdi
callq 0x4a2e
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x82fd(%rip), %rdi      # 0xffe0
leaq 0x23be(%rip), %rsi      # 0xa0a8
callq 0x3160
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x30c0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4a2e
jmp 0x7d10
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4a2e
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyNotE(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>&)
void applyNotE(Goal & g) {
  for(vector<Formula>::iterator i = g.first.begin(); i != g.first.end(); i++) {
    if((*i)->getType() == T_NOT) {
      Formula f = ((Not *)(*i).get())->getOperand();
      g.first.erase(i);
      g.second = f;
      return;
    };
  };

  cerr << "Failed to apply NotE" << endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
cmpq 0x8(%rbx), %r14
je 0x7d7a
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
je 0x7d9c
addq $0x10, %r14
jmp 0x7d61
movq 0x825f(%rip), %rdi      # 0xffe0
leaq 0x234b(%rip), %rsi      # 0xa0d3
callq 0x3160
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x30c0
movq (%r14), %rdi
callq 0x7214
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x4c7c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88be
addq $0x18, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4950
leaq 0x10(%rsp), %rdi
callq 0x4a2e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4a2e
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyConjE1(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>&)
void applyConjE1(Goal & g) {
  for(vector<Formula>::iterator i = g.first.begin(); i != g.first.end(); i++) {
    if((*i)->getType() == T_AND) {
      Formula f = ((And *)(*i).get())->getOperand1();
      g.first.erase(i);
      addAssumption(g.first, f);
      return;
    };
  };

  cerr << "Failed to apply ConjE1" << endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
cmpq 0x8(%rbx), %r14
je 0x7e1a
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x4, %eax
je 0x7e3c
addq $0x10, %r14
jmp 0x7e01
movq 0x81bf(%rip), %rdi      # 0xffe0
leaq 0x22c0(%rip), %rsi      # 0xa0e8
callq 0x3160
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x30c0
movq (%r14), %rdi
callq 0x721a
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x4c7c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88be
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7930
leaq 0x10(%rsp), %rdi
callq 0x4a2e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4a2e
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyConjE2(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>&)
void applyConjE2(Goal & g) {
  for(vector<Formula>::iterator i = g.first.begin(); i != g.first.end(); i++) {
    if((*i)->getType() == T_AND) {
      Formula f = ((And *)(*i).get())->getOperand2();
      g.first.erase(i);
      addAssumption(g.first, f);
      return;
    };
  };

  cerr << "Failed to apply ConjE2" << endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
cmpq 0x8(%rbx), %r14
je 0x7eb6
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x4, %eax
je 0x7ed8
addq $0x10, %r14
jmp 0x7e9d
movq 0x8123(%rip), %rdi      # 0xffe0
leaq 0x223b(%rip), %rsi      # 0xa0ff
callq 0x3160
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x30c0
movq (%r14), %rdi
callq 0x7220
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x4c7c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88be
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7930
leaq 0x10(%rsp), %rdi
callq 0x4a2e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4a2e
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyConjE(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>&)
void applyConjE(Goal & g) {
  for(vector<Formula>::iterator i = g.first.begin(); i != g.first.end(); i++) {
    if((*i)->getType() == T_AND) {
      Formula a = ((And *)(*i).get())->getOperand1();
      Formula b = ((And *)(*i).get())->getOperand2();
      g.first.erase(i);
      addAssumption(g.first, a);
      addAssumption(g.first, b);
      return;
    };
  };

  cerr << "Failed to apply ConjE" << endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
cmpq 0x8(%rbx), %r14
je 0x7f52
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x4, %eax
je 0x7f74
addq $0x10, %r14
jmp 0x7f39
movq 0x8087(%rip), %rdi      # 0xffe0
leaq 0x21b6(%rip), %rsi      # 0xa116
callq 0x3160
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x30c0
movq (%r14), %rdi
callq 0x721a
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x4c7c
movq (%r14), %rdi
callq 0x7220
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x4c7c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88be
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x7930
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7930
leaq 0x10(%rsp), %rdi
callq 0x4a2e
leaq 0x20(%rsp), %rdi
callq 0x4a2e
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x7ff1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4a2e
leaq 0x20(%rsp), %rdi
callq 0x4a2e
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyImpE(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>> const&, std::vector<std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>, std::allocator<std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>>>&)
void applyImpE(const Goal & g, vector<Goal> & subgoals) {
  Formula a, b;
  vector<Formula> ass1, ass2;
  bool applied = false;

  for(vector<Formula>::const_iterator i = g.first.begin(); i != g.first.end(); i++) {
    if((*i)->getType() == T_IMP && !applied) {
      a = ((Imp *)(*i).get())->getOperand1();
      b = ((Imp *)(*i).get())->getOperand2();
      applied = true;
    }
    else {
      addAssumption(ass1, *i);
      addAssumption(ass2, *i);
    };
  };

  if(applied) {
    addAssumption(ass2, b);
    subgoals.push_back(make_pair(ass1, a));
    subgoals.push_back(make_pair(ass2, g.second));
  }
  else
    cerr << "Failed to apply ImpE" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, 0x28(%rsp)
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
leaq 0x10(%rsp), %r12
movaps %xmm0, (%r12)
leaq 0x70(%rsp), %r13
andq $0x0, 0x10(%r13)
leaq 0x30(%rsp), %rbp
andq $0x0, 0x10(%rbp)
movaps %xmm0, (%r13)
movaps %xmm0, (%rbp)
movq (%rdi), %rbx
xorl %r15d, %r15d
cmpq 0x8(%r14), %rbx
je 0x827f
movq (%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x6, %eax
jne 0x8238
testb $0x1, %r15b
je 0x8250
movq %r13, %rdi
movq %rbx, %rsi
callq 0x7930
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x7930
jmp 0x8279
movq (%rbx), %rdi
callq 0x721a
movq %rsp, %rdi
movq %rax, %rsi
callq 0x4950
movq (%rbx), %rdi
callq 0x7220
movq %r12, %rdi
movq %rax, %rsi
callq 0x4950
movb $0x1, %r15b
addq $0x10, %rbx
jmp 0x821f
testb $0x1, %r15b
je 0x82f1
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x7930
leaq 0x48(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movq %rsp, %rdx
callq 0x88ea
movq 0x28(%rsp), %rbx
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x8e4e
leaq 0x48(%rsp), %rdi
callq 0x4892
addq $0x18, %r14
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %r14, %rdx
callq 0x88c4
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x8e4e
leaq 0x48(%rsp), %rdi
callq 0x4892
jmp 0x830c
movq 0x7ce8(%rip), %rdi      # 0xffe0
leaq 0x1e43(%rip), %rsi      # 0xa142
callq 0x3160
movq %rax, %rdi
callq 0x30c0
leaq 0x30(%rsp), %rdi
callq 0x48a8
leaq 0x70(%rsp), %rdi
callq 0x48a8
leaq 0x18(%rsp), %rdi
callq 0x4a2e
leaq 0x8(%rsp), %rdi
callq 0x4a2e
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x834a
jmp 0x835d
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4892
jmp 0x8360
jmp 0x835d
jmp 0x835d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x48a8
leaq 0x70(%rsp), %rdi
callq 0x48a8
leaq 0x18(%rsp), %rdi
callq 0x4a2e
leaq 0x8(%rsp), %rdi
callq 0x4a2e
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyFalseE(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>&)
void applyFalseE(Goal & g) {
  for(vector<Formula>::iterator i = g.first.begin(); i != g.first.end(); i++) {
    if((*i)->getType() == T_FALSE) {
      g.first.erase(i);
      addAssumption(g.first, g.second);
      return;
    };
  };

  cerr << "Failed to apply FalseE" << endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
cmpq 0x8(%rbx), %r14
je 0x83b3
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x1, %eax
je 0x83d5
addq $0x10, %r14
jmp 0x839a
movq 0x7c26(%rip), %rdi      # 0xffe0
leaq 0x1d96(%rip), %rsi      # 0xa157
callq 0x3160
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x30c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88be
leaq 0x18(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7930
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyExcludedMiddle(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>> const&)
bool applyExcludedMiddle(const Goal & g) {
  if(g.second->getType() == T_OR) {
    Formula a = ((Or *)g.second.get())->getOperand1();
    Formula b = ((Or *)g.second.get())->getOperand1();
    if(a->getType() == T_NOT && ((Not *)a.get())->getOperand()->equalTo(b))
      return true;
    if(b->getType() == T_NOT && ((Not *)b.get())->getOperand()->equalTo(a))
      return true;
  };

  cerr << "Failed to apply ExcludedMiddle" << endl;
  return false; 
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x5, %eax
jne 0x84b5
movq 0x18(%rbx), %rdi
callq 0x721a
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x4c7c
movq 0x18(%rbx), %rdi
callq 0x721a
movq %rsp, %rdi
movq %rax, %rsi
callq 0x4c7c
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x8460
movq 0x10(%rsp), %rdi
callq 0x7214
movq (%rax), %rdi
movq (%rdi), %rax
movq %rsp, %rsi
callq *0x10(%rax)
testb %al, %al
jne 0x8489
movq (%rsp), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x84a1
movq (%rsp), %rdi
callq 0x7214
movq (%rax), %rdi
movq (%rdi), %rax
leaq 0x10(%rsp), %rsi
callq *0x10(%rax)
testb %al, %al
je 0x84a1
leaq 0x8(%rsp), %rdi
callq 0x4a2e
leaq 0x18(%rsp), %rdi
callq 0x4a2e
movb $0x1, %al
jmp 0x84d2
leaq 0x8(%rsp), %rdi
callq 0x4a2e
leaq 0x18(%rsp), %rdi
callq 0x4a2e
movq 0x7b24(%rip), %rdi      # 0xffe0
leaq 0x1cab(%rip), %rsi      # 0xa16e
callq 0x3160
movq %rax, %rdi
callq 0x30c0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
jmp 0x84ea
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4a2e
leaq 0x18(%rsp), %rdi
callq 0x4a2e
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyDoubleNegationI(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>&)
void applyDoubleNegationI(Goal & g) {
  if(g.second->getType() == T_NOT && ((Not *)(g.second.get()))->getOperand()->getType() == T_NOT)
    g.second = ((Not*)((Not *)(g.second.get()))->getOperand().get())->getOperand();
  else
    cerr << "Failed to apply DoubleNegationI" << endl;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x8543
addq $0x18, %rbx
movq (%rbx), %rdi
callq 0x7214
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x8543
movq (%rbx), %rdi
callq 0x7214
movq (%rax), %rdi
callq 0x7214
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x4950
movq 0x7a96(%rip), %rdi      # 0xffe0
leaq 0x1c3c(%rip), %rsi      # 0xa18d
callq 0x3160
movq %rax, %rdi
popq %rbx
jmp 0x30c0
// File: /workspace/github_cpp_makefile_star2_O2/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyDoubleNegationE(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>&)
void applyDoubleNegationE(Goal & g) {
  for(vector<Formula>::iterator i = g.first.begin(); i != g.first.end(); i++) {
    if((*i)->getType() == T_NOT && ((Not *)((*i).get()))->getOperand()->getType() == T_NOT) {
      (*i) = ((Not*)((Not *)((*i).get()))->getOperand().get())->getOperand();
      return;
    };
  };

  cerr << "Failed to apply DoubleNegationE" << endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rbx
cmpq 0x8(%r14), %rbx
je 0x8597
movq (%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x8591
movq (%rbx), %rdi
callq 0x7214
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
je 0x85b9
addq $0x10, %rbx
jmp 0x8569
movq 0x7a42(%rip), %rdi      # 0xffe0
leaq 0x1c08(%rip), %rsi      # 0xa1ad
callq 0x3160
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x30c0
movq (%rbx), %rdi
callq 0x7214
movq (%rax), %rdi
callq 0x7214
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4950