LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mshabbirhasan[P]ups-indel/include/seqan/stream/stream_char_array.h
// Function: seqan::_streamReadBlockImpl(bool&, char*, char const*&, char const*&, unsigned long)
inline size_t
_streamReadBlockImpl(bool & eof, char * target, char const * & ptr, char const * & end, size_t maxLen)
{
    char * targetPtr = target;
    size_t valuesRead = 0;
    for (size_t i = 0; i < maxLen; ++i) {
        if (ptr != end) {
            ++valuesRead;
            *targetPtr++ = *ptr++;
        } else {
            eof = true;
            break;
        }
    }
    return valuesRead;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x209a5
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
je 0x2098c
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb (%rax), %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
jmp 0x20995
movq -0x8(%rbp), %rax
movb $0x1, (%rax)
jmp 0x209a5
jmp 0x20997
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x20940
movq -0x38(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/basic/debug_test_system.h
// Function: bool seqan::ClassTest::testFalse<bool>(char const*, int, bool const&, char const*, char const*, ...)
bool testFalse(const char * file, int line,
               const T & value_, const char * expression_,
               const char * comment, ...)
{
    if (value_)
    {
        // Increase global error count.
        StaticData::thisTestOk() = false;
        StaticData::errorCount() += 1;
        // Print assertion failure text, with comment if any is given.
        std::cerr << file << ":" << line << " Assertion failed : "
                  << expression_ << " should be false but was " << (value_);
        if (comment)
        {
            std::cerr << " (";
            va_list args;
            va_start(args, comment);
            vfprintf(stderr, comment, args);
            va_end(args);
            std::cerr << ")";
        }
        std::cerr << std::endl;
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x209ee
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, (%rax)
je 0x20b15
callq 0xb9c0
movb $0x0, (%rax)
callq 0xb2d0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rsi
movq 0x175bc(%rip), %rdi     # 0x37ff0
callq 0x4430
movq %rax, %rdi
leaq 0x8134(%rip), %rsi      # 0x28b77
callq 0x4430
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x4740
movq %rax, %rdi
leaq 0x7b99(%rip), %rsi      # 0x285f6
callq 0x4430
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x4430
movq %rax, %rdi
leaq 0x8060(%rip), %rsi      # 0x28ad8
callq 0x4430
movq %rax, %rdi
movq -0x20(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x47b0
cmpq $0x0, -0x30(%rbp)
je 0x20afc
movq 0x17552(%rip), %rdi     # 0x37ff0
leaq 0x7c2c(%rip), %rsi      # 0x286d1
callq 0x4430
leaq -0x50(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x28, (%rax)
movq 0x174f3(%rip), %rax     # 0x37fc8
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x4590
leaq -0x50(%rbp), %rax
movq 0x17500(%rip), %rdi     # 0x37ff0
leaq 0x7d93(%rip), %rsi      # 0x2888a
callq 0x4430
movq 0x174ed(%rip), %rdi     # 0x37ff0
movq 0x17496(%rip), %rsi     # 0x37fa0
callq 0x4480
movb $0x0, -0x1(%rbp)
jmp 0x20b19
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: mshabbirhasan[P]ups-indel/include/seqan/stream/tokenize.h
// Function: int seqan::readNChars<seqan::String<char, seqan::Alloc<void>>, seqan::Stream<seqan::CharArray<char const*>>, seqan::SinglePass<void>>(seqan::String<char, seqan::Alloc<void>>&, seqan::RecordReader<seqan::Stream<seqan::CharArray<char const*>>, seqan::SinglePass<void>>&, unsigned int)
inline int
readNChars(TBuffer & buffer,
           RecordReader<TStream, TPass> & reader,
           unsigned const n)
{
    SEQAN_CHECKPOINT


    reserve(buffer, n, Exact());

    for (unsigned i = 0; i < n; ++i)
    {
        if (atEnd(reader))
            return EOF_BEFORE_SUCCESS;
        appendValue(buffer, value(reader));
        goNext(reader);
        if (resultCode(reader) != 0)
            return resultCode(reader);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x17970
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x20bc9
movq -0x18(%rbp), %rdi
callq 0x1eb60
testb $0x1, %al
jne 0x20b6d
jmp 0x20b76
movl $0x400, -0x4(%rbp)      # imm = 0x400
jmp 0x20bd0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ebc0
movq -0x30(%rbp), %rdi
movb %al, -0x25(%rbp)
leaq -0x25(%rbp), %rsi
callq 0x176a0
movq -0x18(%rbp), %rdi
callq 0x1ec20
movq -0x18(%rbp), %rdi
callq 0x20fe0
cmpl $0x0, %eax
je 0x20bbc
movq -0x18(%rbp), %rdi
callq 0x20fe0
movl %eax, -0x4(%rbp)
jmp 0x20bd0
jmp 0x20bbe
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x20b56
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: mshabbirhasan[P]ups-indel/include/seqan/bam_io/bam_sam_conversion.h
// Function: void seqan::assignTagsBamToSam<seqan::String<char, seqan::Alloc<void>>, seqan::String<char, seqan::Alloc<void>>>(seqan::String<char, seqan::Alloc<void>>&, seqan::String<char, seqan::Alloc<void>> const&)
void assignTagsBamToSam(TTarget & target, TSource const & source)
{
    // Handle case of empty source sequence.
    if (empty(source))
        clear(target);

    clear(target);

    typedef typename Iterator<TSource const, Rooted>::Type TSourceIter;
    TSourceIter it = begin(source, Rooted());

    bool first = true;
    while (!atEnd(it))
    {
        if (!first)
            appendValue(target, '\t');
        first = false;
        _assignTagsBamToSamOneTag(target, it);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf8e0
testb $0x1, %al
jne 0x236af
jmp 0x236b8
movq -0x8(%rbp), %rdi
callq 0x13670
movq -0x8(%rbp), %rdi
callq 0x13670
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x238a0
movb $0x1, -0x22(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x238d0
xorb $-0x1, %al
testb $0x1, %al
jne 0x236e3
jmp 0x2370d
testb $0x1, -0x22(%rbp)
jne 0x236fa
movq -0x8(%rbp), %rdi
movb $0x9, -0x23(%rbp)
leaq -0x23(%rbp), %rsi
callq 0x176a0
movb $0x0, -0x22(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x23910
jmp 0x236d2
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x1e649(%rip), %rax     # 0x23fb0
movq (%rax), %rdi
leaq 0x11d0b(%rip), %rsi     # 0x1767c
movb $0x0, %al
callq 0x42d0
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x59b5
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
movq 0x1e61d(%rip), %rax     # 0x23fb0
movq (%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x11ce6(%rip), %rsi     # 0x17686
movb $0x0, %al
callq 0x42d0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x5978
movq 0x1e5f4(%rip), %rax     # 0x23fb0
movq (%rax), %rdi
leaq 0x11904(%rip), %rsi     # 0x172ca
movb $0x0, %al
callq 0x42d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0xf, -0xc(%rbp)
jge 0x5a12
leaq 0x11cf7(%rip), %rax     # 0x17703
movq %rax, -0x30(%rbp)
jmp 0x5a1f
leaq 0x11c79(%rip), %rax     # 0x17692
movq %rax, -0x30(%rbp)
jmp 0x5a1f
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %edi
callq 0x6aa0
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
leaq 0x11c49(%rip), %rsi     # 0x1768a
movb $0x0, %al
callq 0x42d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x6ac0
movq -0x8(%rbp), %rdi
leaq 0x11d5c(%rip), %rsi     # 0x177c3
movb $0x0, %al
callq 0x42d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: shisharka[P]interactive_deduction/interactive_deduction.tab.cpp
// Function: yy_reduce_print(signed char*, YYSTYPE*, int, std::shared_ptr<BaseFormula>&)
static void
yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,
                 int yyrule, Formula & formula)
{
  int yylno = yyrline[yyrule];
  int yynrhs = yyr2[yyrule];
  int yyi;
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
             yyrule - 1, yylno);
  /* The symbols being reduced.  */
  for (yyi = 0; yyi < yynrhs; yyi++)
    {
      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
      yy_symbol_print (stderr,
                       YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
                       &yyvsp[(yyi + 1) - (yynrhs)], formula);
      YYFPRINTF (stderr, "\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x117b5(%rip), %rax     # 0x17257
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x11763(%rip), %rax     # 0x17217
movsbl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
movq 0x1e4ee(%rip), %rax     # 0x23fb0
movq (%rax), %rdi
movl -0x14(%rbp), %edx
subl $0x1, %edx
movl -0x24(%rbp), %ecx
leaq 0x11c5d(%rip), %rsi     # 0x17732
movb $0x0, %al
callq 0x42d0
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x5b7e
movq 0x1e4ba(%rip), %rax     # 0x23fb0
movq (%rax), %rdi
movl -0x2c(%rbp), %edx
addl $0x1, %edx
leaq 0x11c52(%rip), %rsi     # 0x17758
movb $0x0, %al
callq 0x42d0
movq 0x1e49c(%rip), %rax     # 0x23fb0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
subl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0x1170b(%rip), %rax     # 0x17240
movsbl (%rax,%rcx), %esi
movq -0x10(%rbp), %rdx
movl -0x2c(%rbp), %eax
addl $0x1, %eax
subl -0x28(%rbp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x59e0
movq 0x1e451(%rip), %rax     # 0x23fb0
movq (%rax), %rdi
leaq 0x11761(%rip), %rsi     # 0x172ca
movb $0x0, %al
callq 0x42d0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5ae3
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: shisharka[P]interactive_deduction/lex.yy.c
// Function: yy_try_NUL_trans(int)
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		(yy_last_accepting_state) = yy_current_state;
		(yy_last_accepting_cpos) = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 30 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 29);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x13a92(%rip), %rax     # 0x24280
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x73cf(%rip), %rax      # 0x17bd0
cmpw $0x0, (%rax,%rcx,2)
je 0x1081c
movl -0x4(%rbp), %eax
movl %eax, 0x13a7b(%rip)     # 0x2428c
movq -0x10(%rbp), %rax
movq %rax, 0x13a74(%rip)     # 0x24290
jmp 0x1081e
movslq -0x4(%rbp), %rcx
leaq 0x7457(%rip), %rax      # 0x17c80
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x73d3(%rip), %rax      # 0x17c10
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x10873
movslq -0x4(%rbp), %rcx
leaq 0x746f(%rip), %rax      # 0x17cc0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x1e, -0x4(%rbp)
jl 0x10871
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x7495(%rip), %rax      # 0x17d00
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0x1081e
movslq -0x4(%rbp), %rcx
leaq 0x7402(%rip), %rax      # 0x17c80
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x748e(%rip), %rax      # 0x17d20
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x1d, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x108b5
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x108bb
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x2, %eax
je 0x11e44
movb $0x0, -0x1(%rbp)
jmp 0x11e6f
movq -0x18(%rbp), %rdi
callq 0x120f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11a30
movq -0x28(%rbp), %rsi
movq %rax, %rdi
addq $0x18, %rsi
callq 0x12110
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: shisharka[P]interactive_deduction/formula.cpp
// Function: UnaryConnective::equalTo(std::shared_ptr<BaseFormula> const&) const
bool UnaryConnective::equalTo(const Formula & f) const {
  if(f->getType() != getType())
    return false;

  UnaryConnective * uc = (UnaryConnective *) f.get();
  
  return uc->getOperand()->equalTo(_op);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x30(%rbp), %rdi
movl %eax, -0x24(%rbp)
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
je 0x11ec4
movb $0x0, -0x1(%rbp)
jmp 0x11ef8
movq -0x18(%rbp), %rdi
callq 0x120f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11a50
movq %rax, %rdi
callq 0x120d0
movq -0x30(%rbp), %rsi
movq %rax, %rdi
addq $0x18, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x30(%rbp), %rdi
movl %eax, -0x24(%rbp)
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
je 0x11f54
movb $0x0, -0x1(%rbp)
jmp 0x11fbe
movq -0x18(%rbp), %rdi
callq 0x120f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11a70
movq %rax, %rdi
callq 0x120d0
movq -0x30(%rbp), %rsi
movq %rax, %rdi
addq $0x18, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x31(%rbp)
jne 0x11f91
jmp 0x11fb6
movq -0x20(%rbp), %rdi
callq 0x11a90
movq %rax, %rdi
callq 0x120d0
movq -0x30(%rbp), %rsi
movq %rax, %rdi
addq $0x28, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe680
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x12d66
movq -0x10(%rbp), %rdi
callq 0x120d0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x14500
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x12d55
jmp 0x12d59
movb $0x0, -0x11(%rbp)
jmp 0x12d5b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x12d0b
testb $0x1, -0x11(%rbp)
je 0x12d79
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x14520
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe7a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe7d0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xeb70
testb $0x1, %al
jne 0x12dc4
jmp 0x12e57
leaq -0x20(%rbp), %rdi
callq 0xebe0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x8410
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x120d0
movq -0x58(%rbp), %rsi
movq %rax, %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movb %al, -0x49(%rbp)
jmp 0x12dff
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x12e08
jmp 0x12e2c
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x12e33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7260
jmp 0x12e88
movl $0x0, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7260
movl -0x48(%rbp), %eax
testl %eax, %eax
je 0x12e47
jmp 0x12e45
jmp 0x12e7d
jmp 0x12e49
leaq -0x20(%rbp), %rdi
callq 0xec00
jmp 0x12dae
movq 0x1118a(%rip), %rdi     # 0x23fe8
leaq 0x51bf(%rip), %rsi      # 0x18024
callq 0x41d0
movq %rax, %rdi
movq 0x1110c(%rip), %rsi     # 0x23f80
callq 0x4200
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4370
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x12f41
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a50
movq %rax, %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x8410
movq -0x40(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x12cf0
jmp 0x12efa
leaq -0x38(%rbp), %rdi
callq 0x70d0
jmp 0x12f05
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
leaq -0x38(%rbp), %rsi
callq 0x14590
leaq -0x38(%rbp), %rdi
callq 0x7170
leaq -0x18(%rbp), %rdi
callq 0x7260
jmp 0x12f63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x7260
jmp 0x12f69
movq 0x110a0(%rip), %rdi     # 0x23fe8
leaq 0x50f0(%rip), %rsi      # 0x1803f
callq 0x41d0
movq %rax, %rdi
movq 0x11022(%rip), %rsi     # 0x23f80
callq 0x4200
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4370
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x4, %eax
jne 0x13093
leaq -0x38(%rbp), %rdi
callq 0x145c0
leaq -0x60(%rbp), %rdi
callq 0x145c0
jmp 0x12fc5
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x14600
jmp 0x12fd4
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a70
movq %rax, -0x78(%rbp)
jmp 0x12fef
movq -0x78(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x6b30
movq -0x8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x14600
jmp 0x1300b
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a90
movq %rax, -0x80(%rbp)
jmp 0x13026
movq -0x80(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x6b30
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x14850
jmp 0x13042
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x14850
jmp 0x13051
leaq -0x60(%rbp), %rdi
callq 0x7450
leaq -0x38(%rbp), %rdi
callq 0x7450
jmp 0x130b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x13088
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x7450
leaq -0x38(%rbp), %rdi
callq 0x7450
jmp 0x130be
movq 0x10f4e(%rip), %rdi     # 0x23fe8
leaq 0x4fb3(%rip), %rsi      # 0x18054
callq 0x41d0
movq %rax, %rdi
movq 0x10ed0(%rip), %rsi     # 0x23f80
callq 0x4200
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x4370
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x5, %eax
jne 0x1311d
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a70
movq %rax, %rsi
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x6b30
jmp 0x1313f
movq 0x10ec4(%rip), %rdi     # 0x23fe8
leaq 0x4f3f(%rip), %rsi      # 0x1806a
callq 0x41d0
movq %rax, %rdi
movq 0x10e46(%rip), %rsi     # 0x23f80
callq 0x4200
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x5, %eax
jne 0x1319d
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a90
movq %rax, %rsi
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x6b30
jmp 0x131bf
movq 0x10e44(%rip), %rdi     # 0x23fe8
leaq 0x4ed6(%rip), %rsi      # 0x18081
callq 0x41d0
movq %rax, %rdi
movq 0x10dc6(%rip), %rsi     # 0x23f80
callq 0x4200
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x6, %eax
jne 0x132a5
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a70
movq %rax, %rsi
leaq -0x18(%rbp), %rdi
callq 0x8410
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a90
movq %rax, -0x40(%rbp)
jmp 0x13236
movq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x8410
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x12cf0
jmp 0x13252
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
leaq -0x28(%rbp), %rsi
callq 0x6b30
leaq -0x28(%rbp), %rdi
callq 0x7260
leaq -0x18(%rbp), %rdi
callq 0x7260
jmp 0x132c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x1329a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7260
leaq -0x18(%rbp), %rdi
callq 0x7260
jmp 0x132cd
movq 0x10d3c(%rip), %rdi     # 0x23fe8
leaq 0x4de5(%rip), %rsi      # 0x18098
callq 0x41d0
movq %rax, %rdi
movq 0x10cbe(%rip), %rsi     # 0x23f80
callq 0x4200
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x4370
nopw %cs:(%rax,%rax)
// File: shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyTrueI(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>> const&)
bool applyTrueI(const Goal & g) {
  if(g.second->getType() == T_TRUE)
    return true;
  else {
    cerr << "Failed to apply TrueI" << endl;
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x0, %eax
jne 0x1330c
movb $0x1, -0x1(%rbp)
jmp 0x13332
movq 0x10cd5(%rip), %rdi     # 0x23fe8
leaq 0x4d93(%rip), %rsi      # 0x180ad
callq 0x41d0
movq %rax, %rdi
movq 0x10c57(%rip), %rsi     # 0x23f80
callq 0x4200
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x148c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14930
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x148f0
testb $0x1, %al
jne 0x1337c
jmp 0x13440
leaq -0x10(%rbp), %rdi
callq 0x14960
movq %rax, %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x1342a
leaq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x14960
movq %rax, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a50
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x8410
movq -0x68(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x149f0
movq -0x60(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x14980
movq %rax, -0x58(%rbp)
jmp 0x133ef
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
leaq -0x28(%rbp), %rsi
callq 0x6b30
leaq -0x28(%rbp), %rdi
callq 0x7260
jmp 0x13462
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7260
jmp 0x13468
jmp 0x1342c
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x14a30
movq %rax, -0x50(%rbp)
jmp 0x13359
movq 0x10ba1(%rip), %rdi     # 0x23fe8
leaq 0x4c75(%rip), %rsi      # 0x180c3
callq 0x41d0
movq %rax, %rdi
movq 0x10b23(%rip), %rsi     # 0x23f80
callq 0x4200
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4370
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x148c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14930
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x148f0
testb $0x1, %al
jne 0x134bc
jmp 0x1357e
leaq -0x10(%rbp), %rdi
callq 0x14960
movq %rax, %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x4, %eax
jne 0x13568
leaq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x14960
movq %rax, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a70
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x8410
movq -0x68(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x149f0
movq -0x60(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x14980
movq %rax, -0x58(%rbp)
jmp 0x1352f
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12cf0
jmp 0x13546
leaq -0x28(%rbp), %rdi
callq 0x7260
jmp 0x135a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7260
jmp 0x135a6
jmp 0x1356a
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x14a30
movq %rax, -0x50(%rbp)
jmp 0x13499
movq 0x10a63(%rip), %rdi     # 0x23fe8
leaq 0x4b4c(%rip), %rsi      # 0x180d8
callq 0x41d0
movq %rax, %rdi
movq 0x109e5(%rip), %rsi     # 0x23f80
callq 0x4200
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4370
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x148c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14930
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x148f0
testb $0x1, %al
jne 0x135ec
jmp 0x136ae
leaq -0x10(%rbp), %rdi
callq 0x14960
movq %rax, %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x4, %eax
jne 0x13698
leaq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x14960
movq %rax, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a90
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x8410
movq -0x68(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x149f0
movq -0x60(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x14980
movq %rax, -0x58(%rbp)
jmp 0x1365f
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12cf0
jmp 0x13676
leaq -0x28(%rbp), %rdi
callq 0x7260
jmp 0x136d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7260
jmp 0x136d6
jmp 0x1369a
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x14a30
movq %rax, -0x50(%rbp)
jmp 0x135c9
movq 0x10933(%rip), %rdi     # 0x23fe8
leaq 0x4a33(%rip), %rsi      # 0x180ef
callq 0x41d0
movq %rax, %rdi
movq 0x108b5(%rip), %rsi     # 0x23f80
callq 0x4200
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4370
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x148c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14930
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x148f0
testb $0x1, %al
jne 0x1371f
jmp 0x1383c
leaq -0x10(%rbp), %rdi
callq 0x14960
movq %rax, %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x4, %eax
jne 0x13826
leaq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x14960
movq %rax, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a70
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x8410
movq -0x70(%rbp), %rdi
callq 0x14960
movq %rax, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a90
movq %rax, -0x68(%rbp)
jmp 0x13789
movq -0x68(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x8410
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x149f0
movq -0x80(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x14980
movq %rax, -0x78(%rbp)
jmp 0x137be
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12cf0
jmp 0x137d5
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x12cf0
jmp 0x137e4
leaq -0x38(%rbp), %rdi
callq 0x7260
leaq -0x28(%rbp), %rdi
callq 0x7260
jmp 0x1385e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1381b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7260
leaq -0x28(%rbp), %rdi
callq 0x7260
jmp 0x13867
jmp 0x13828
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x14a30
movq %rax, -0x60(%rbp)
jmp 0x136fc
movq 0x107a5(%rip), %rdi     # 0x23fe8
leaq 0x48bc(%rip), %rsi      # 0x18106
callq 0x41d0
movq %rax, %rdi
movq 0x10727(%rip), %rsi     # 0x23f80
callq 0x4200
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4370
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x148c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14930
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x148f0
testb $0x1, %al
jne 0x13e79
jmp 0x13ee6
leaq -0x10(%rbp), %rdi
callq 0x14960
movq %rax, %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x1, %eax
jne 0x13ed0
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x149f0
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14980
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
callq 0x12cf0
jmp 0x13f08
jmp 0x13ed2
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x14a30
movq %rax, -0x30(%rbp)
jmp 0x13e59
movq 0x100fb(%rip), %rdi     # 0x23fe8
leaq 0x4253(%rip), %rsi      # 0x18147
callq 0x41d0
movq %rax, %rdi
movq 0x1007d(%rip), %rsi     # 0x23f80
callq 0x4200
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x5, %eax
jne 0x140ba
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a70
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x8410
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a70
movq %rax, -0x48(%rbp)
jmp 0x13f76
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x8410
leaq -0x20(%rbp), %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, -0x4c(%rbp)
jmp 0x13f9c
movl -0x4c(%rbp), %eax
cmpl $0x3, %eax
jne 0x1401d
leaq -0x20(%rbp), %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a50
movq %rax, -0x58(%rbp)
jmp 0x13fbb
movq -0x58(%rbp), %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x30(%rbp), %rsi
callq *%rax
movb %al, -0x59(%rbp)
jmp 0x13fd9
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x13fe2
jmp 0x1401d
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x14090
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x140af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7260
jmp 0x140af
leaq -0x30(%rbp), %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, -0x60(%rbp)
jmp 0x14036
movl -0x60(%rbp), %eax
cmpl $0x3, %eax
jne 0x14089
leaq -0x30(%rbp), %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a50
movq %rax, -0x68(%rbp)
jmp 0x14055
movq -0x68(%rbp), %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x20(%rbp), %rsi
callq *%rax
movb %al, -0x69(%rbp)
jmp 0x14073
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x1407c
jmp 0x14089
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x14090
movl $0x0, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7260
leaq -0x20(%rbp), %rdi
callq 0x7260
movl -0x40(%rbp), %eax
testl %eax, %eax
je 0x140ad
jmp 0x140ab
jmp 0x140e0
jmp 0x140ba
leaq -0x20(%rbp), %rdi
callq 0x7260
jmp 0x140eb
movq 0xff27(%rip), %rdi      # 0x23fe8
leaq 0x4096(%rip), %rsi      # 0x1815e
callq 0x41d0
movq %rax, %rdi
movq 0xfea9(%rip), %rsi      # 0x23f80
callq 0x4200
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4370
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x14187
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a50
movq %rax, %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x14187
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a50
movq %rax, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a50
movq %rax, %rsi
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x6b30
jmp 0x141a9
movq 0xfe5a(%rip), %rdi      # 0x23fe8
leaq 0x3fe8(%rip), %rsi      # 0x1817d
callq 0x41d0
movq %rax, %rdi
movq 0xfddc(%rip), %rsi      # 0x23f80
callq 0x4200
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x148c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14930
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x148f0
testb $0x1, %al
jne 0x141ec
jmp 0x14292
leaq -0x10(%rbp), %rdi
callq 0x14960
movq %rax, %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x1427c
leaq -0x10(%rbp), %rdi
callq 0x14960
movq %rax, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a50
movq %rax, %rdi
callq 0x120d0
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x1427c
leaq -0x10(%rbp), %rdi
callq 0x14960
movq %rax, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a50
movq %rax, %rdi
callq 0x120f0
movq %rax, %rdi
callq 0x11a50
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x14960
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x6b30
jmp 0x142b4
jmp 0x1427e
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x14a30
movq %rax, -0x20(%rbp)
jmp 0x141c9
movq 0xfd4f(%rip), %rdi      # 0x23fe8
leaq 0x3efd(%rip), %rsi      # 0x1819d
callq 0x41d0
movq %rax, %rdi
movq 0xfcd1(%rip), %rsi      # 0x23f80
callq 0x4200
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: operator<<(std::ostream&, std::deque<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>>>> const&)
ostream & operator << (ostream & ostr, const Goals & goals) {
  ostr << endl << "Goals:" << endl;
  for(unsigned i = 0; i < goals.size(); i++) {
    ostr << i + 1 << ". ";
    for(unsigned j = 0; j < goals[i].first.size(); j++) {
      ostr << goals[i].first[j];
      if(j < goals[i].first.size() - 1)
        ostr << " , ";
    };
    ostr << " |-- ";
    ostr << goals[i].second << endl;
  };
  
  return ostr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq 0xfbf5(%rip), %rsi      # 0x23f80
callq 0x4200
movq %rax, %rdi
leaq 0x3e23(%rip), %rsi      # 0x181bd
callq 0x41d0
movq %rax, %rdi
movq 0xfbd7(%rip), %rsi      # 0x23f80
callq 0x4200
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x74e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x144f2
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0x42b0
movq %rax, %rdi
leaq 0x3dd6(%rip), %rsi      # 0x181c4
callq 0x41d0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x14b60
movq %rax, %rdi
callq 0xe680
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x1449f
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x14b60
movq %rax, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x14b90
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x118f0
movl -0x18(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x14b60
movq %rax, %rdi
callq 0xe680
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x1448f
movq -0x8(%rbp), %rdi
leaq 0x3d3d(%rip), %rsi      # 0x181c7
callq 0x41d0
jmp 0x14491
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x143fa
movq -0x8(%rbp), %rdi
leaq 0x3d21(%rip), %rsi      # 0x181cb
callq 0x41d0
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x14b60
movq -0x40(%rbp), %rdi
movq %rax, %rsi
addq $0x18, %rsi
callq 0x118f0
movq %rax, %rdi
movq 0xfaa1(%rip), %rsi      # 0x23f80
callq 0x4200
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x143b5
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)