LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]SMLA/src/SMLA_DIO.cpp
// Function: ramulator::SMLA_DIO::init_rowopen()
void SMLA_DIO::init_rowopen()
{
    // RD
    rowopen[int(Level::Bank)][int(Command::RD)] = [] (DRAM<SMLA_DIO>* node, Command cmd, int id) {
        switch (int(node->state)) {
            case int(State::Closed): return false;
            case int(State::Opened): return true;
            default: assert(false);
        }};

    // WR
    rowopen[int(Level::Bank)][int(Command::WR)] = rowopen[int(Level::Bank)][int(Command::RD)];
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
leaq 0x1df6(%rip), %rcx      # 0x48522
movq %rcx, 0x18(%rsp)
leaq 0x1e22(%rip), %rdx      # 0x4855a
movq %rdx, 0x10(%rsp)
movups 0x1440(%rdi), %xmm1
movaps %xmm1, (%rsp)
movups %xmm0, 0x1440(%rdi)
movq 0x1450(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rdx, 0x1450(%rdi)
movq 0x1458(%rdi), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, 0x1458(%rdi)
testq %rax, %rax
je 0x46787
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x1440(%rbx), %rsi
addq $0x1460, %rbx           # imm = 0x1460
movq %rbx, %rdi
callq 0x48a46
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x7ce9
nop
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/stx/stxtyper.cpp
// Function: (anonymous namespace)::Operon::betterEq((anonymous namespace)::Operon const&) const
bool betterEq (const Operon &other) const
    {  if (al1->targetName != other. al1->targetName)
         return false;
       if (! other. insideEq (*this, 3 * slack))  // PAR
         return false;
     #ifdef PROT_MATCH
       if (perfect () > other. perfect ())
         return true;
       if (perfect () < other. perfect ())
         return false;
     #endif
       return getIdentity () >= other. getIdentity ();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r12
movq (%rsi), %r15
movq 0x60(%r12), %rdx
cmpq 0x60(%r15), %rdx
jne 0x20bbe
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x20b7a
movq 0x58(%r15), %rsi
movq 0x58(%r12), %rdi
callq 0xa5a0
testl %eax, %eax
jne 0x20bbe
movb 0x98(%r15), %al
cmpb 0x98(%r12), %al
jne 0x20bbe
movq 0x30(%r15), %rax
addq $0x5a, %rax
cmpq 0x30(%r12), %rax
jb 0x20bbe
movq 0x8(%rbx), %rax
testq %rax, %rax
cmoveq %r15, %rax
movq 0x8(%r14), %rcx
testq %rcx, %rcx
cmoveq %r12, %rcx
movq 0x38(%rcx), %rcx
addq $0x5a, %rcx
cmpq %rcx, 0x38(%rax)
jbe 0x20bcc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%r14), %rdx
movq 0x8(%r12), %rax
testq %rdx, %rdx
je 0x20bde
addq 0x8(%rdx), %rax
movq (%r12), %rcx
testq %rdx, %rdx
je 0x20bea
addq (%rdx), %rcx
movq %rax, %xmm3
movq 0x58419(%rip), %xmm1    # 0x79010
punpckldq %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
movapd 0x5841d(%rip), %xmm2    # 0x79020
subpd %xmm2, %xmm3
movapd %xmm3, %xmm0
unpckhpd %xmm3, %xmm0            # xmm0 = xmm0[1],xmm3[1]
addsd %xmm3, %xmm0
movq %rcx, %xmm4
punpckldq %xmm1, %xmm4    # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1]
subpd %xmm2, %xmm4
movapd %xmm4, %xmm3
unpckhpd %xmm4, %xmm3            # xmm3 = xmm3[1],xmm4[1]
addsd %xmm4, %xmm3
movq 0x8(%rbx), %rcx
movq 0x8(%r15), %rax
testq %rcx, %rcx
je 0x20c3d
addq 0x8(%rcx), %rax
divsd %xmm3, %xmm0
movq (%r15), %rdx
testq %rcx, %rcx
je 0x20c4c
addq (%rcx), %rdx
movq %rax, %xmm3
punpckldq %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
subpd %xmm2, %xmm3
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
addsd %xmm3, %xmm4
movq %rdx, %xmm3
punpckldq %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
subpd %xmm2, %xmm3
movapd %xmm3, %xmm1
unpckhpd %xmm3, %xmm1            # xmm1 = xmm1[1],xmm3[1]
addsd %xmm3, %xmm1
divsd %xmm1, %xmm4
ucomisd %xmm4, %xmm0
setae %al
jmp 0x20bc0
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/stx/stxtyper.cpp
// Function: (anonymous namespace)::Operon::reportLess((anonymous namespace)::Operon const&, (anonymous namespace)::Operon const&)
static bool reportLess (const Operon &a,
                          const Operon &b)
    { LESS_PART (a, b, al1->targetName);
      LESS_PART (a, b, al1->targetStart);
      LESS_PART (a, b, al1->targetEnd);
      LESS_PART (b, a, al1->targetStrand);
      LESS_PART (a, b, hasAl2 ());
      // Tie resolution
      LESS_PART (a, b, al1->refAccession);
      LESS_PART (a, b, getRefAccession2 ());
      return false;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
addq $0x58, %rdi
movq (%rsi), %rsi
addq $0x58, %rsi
callq 0xa050
movb $0x1, %bl
testl %eax, %eax
js 0x2147d
movq (%r15), %rdi
addq $0x58, %rdi
movq (%r14), %rsi
addq $0x58, %rsi
callq 0xa050
testl %eax, %eax
js 0x2147b
movq (%r14), %rdi
movq 0x30(%rdi), %rax
movq (%r15), %rsi
movq 0x30(%rsi), %rcx
cmpq %rcx, %rax
jb 0x2147d
jbe 0x2148e
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x38(%rdi), %rax
movq 0x38(%rsi), %rcx
cmpq %rcx, %rax
jb 0x2147d
ja 0x2147b
movb 0x98(%rsi), %al
movb 0x98(%rdi), %cl
cmpb %cl, %al
jb 0x2147d
ja 0x2147b
movq 0x8(%r14), %rax
testq %rax, %rax
sete %dl
movq 0x8(%r15), %rcx
testq %rcx, %rcx
setne %r8b
testb %r8b, %dl
jne 0x2147d
testq %rcx, %rcx
sete %cl
testq %rax, %rax
setne %al
testb %cl, %al
jne 0x2147b
movl $0xa0, %r12d
addq %r12, %rdi
addq %r12, %rsi
callq 0x265b3
testb %al, %al
jne 0x2147d
movq (%r15), %rdi
addq %r12, %rdi
addq (%r14), %r12
movq %r12, %rsi
callq 0x265b3
testb %al, %al
jne 0x2147b
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x22f14
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x22f14
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %r12
movq %r12, %rsi
callq 0x265b3
movl %eax, %ebp
movq (%r12), %rdi
leaq 0x38(%rsp), %r13
cmpq %r13, %rdi
je 0x21550
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa580
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x2156c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa580
testb %bpl, %bpl
jne 0x2147d
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x22f14
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x22f14
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rbx
movq %rbx, %rsi
callq 0x265b3
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x215b6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa580
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2147b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa580
jmp 0x2147b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
jne 0x215f6
jmp 0x21603
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x21603
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa580
movq %rbx, %rdi
callq 0xa9d0
jmp 0x2160d
movq %rax, %rdi
callq 0x23bdd
nop
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/stx/stxtyper.cpp
// Function: (anonymous namespace)::stxType_reported_operon2elementName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string stxType_reported_operon2elementName (const string &stxType_reported,
                                            const string &operon)
{
  string elementName (stxType_reported  + " operon");
       if (operon == "FRAMESHIFT")
    elementName += " with frameshift";
  else if (operon == "INTERNAL_STOP")
    elementName += " with internal stop";
  else if (contains (operon, "PARTIAL"))
    elementName = "Partial " + elementName;
  else if (operon == "EXTENDED")
    elementName = "Extended " + elementName;
  else if (contains (operon, "NOVEL"))
    elementName = "Novel " + elementName;
    
  return elementName;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x2425a
leaq 0x5820c(%rip), %rsi     # 0x79ebe
movq %rbx, %rdi
callq 0xaa80
leaq 0x58175(%rip), %rsi     # 0x79e36
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x21d70
leaq 0x58169(%rip), %rsi     # 0x79e41
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x21d79
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x58184(%rip), %rsi     # 0x79e7c
leaq 0x58184(%rip), %rdx     # 0x79e83
movq %rsp, %rdi
callq 0x2701a
movq (%rsp), %rsi
movq 0x8(%rsp), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0xa9a0
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x21d33
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa580
cmpq $-0x1, %r15
je 0x21d99
leaq 0x581ab(%rip), %rsi     # 0x79eeb
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x25f18
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa6c0
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x21d88
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa580
jmp 0x21d88
leaq 0x5814f(%rip), %rsi     # 0x79ec6
jmp 0x21d80
leaq 0x58157(%rip), %rsi     # 0x79ed7
movq %rbx, %rdi
callq 0xaa80
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x580d3(%rip), %rsi     # 0x79e73
movq %r14, %rdi
callq 0xa160
testl %eax, %eax
je 0x21e0e
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x58603(%rip), %rsi     # 0x7a3bc
leaq 0x58601(%rip), %rdx     # 0x7a3c1
callq 0x2701a
movq (%rsp), %rsi
movq 0x8(%rsp), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0xa9a0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x21df1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa580
cmpq $-0x1, %r14
je 0x21d88
leaq 0x58100(%rip), %rsi     # 0x79efe
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x25f18
jmp 0x21d4b
leaq 0x580df(%rip), %rsi     # 0x79ef4
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x25f18
jmp 0x21d4b
jmp 0x21e31
jmp 0x21e31
jmp 0x21e31
jmp 0x21e31
jmp 0x21e31
jmp 0x21e31
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x21e48
movq (%r12), %rsi
incq %rsi
callq 0xa580
movq %r14, %rdi
callq 0xa9d0
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/stx/stxtyper.cpp
// Function: (anonymous namespace)::BlastAlignment::perfect() const
bool perfect () const
    { return    ! truncated ()
             && ! partial ()
             && ! c_extended ()  // redundant
             && ! frameshift
             && ! stopCodon;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x21770
testb %al, %al
jne 0x22208
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
movq %rdx, %xmm0
movq 0x56e64(%rip), %xmm1    # 0x79010
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x56e68(%rip), %xmm2    # 0x79020
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
movq 0x28(%rbx), %rdx
movq %rdx, %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
subpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd %xmm1, %xmm3
movsd 0x56e87(%rip), %xmm0    # 0x79078
ucomisd %xmm3, %xmm0
ja 0x22208
incq %rcx
xorq %rdx, %rcx
orq %rcx, %rax
je 0x22208
cmpb $0x0, 0x51(%rbx)
je 0x2220c
xorl %eax, %eax
popq %rbx
retq
movb 0x50(%rbx), %al
xorb $0x1, %al
jmp 0x2220a
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/./environment.hpp
// Function: ALisp::Environment::create(ALisp::Cell const&, ALisp::Cell)
void create(const Cell &cell, val_type val) {
			switch (cell.type()) {
				case CellType::Atom: return create(cell.atomId(), val);
				case CellType::String: return create(Atoms::Declare(cell.str().c_str()), val);
				default: throw Exception("Cannot convert cell to atom");
			}
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0xa6a1
movl 0x8(%rax), %eax
jmp 0xa6a3
xorl %eax, %eax
cmpl $0x4, %eax
je 0xa6e2
cmpl $0x1, %eax
jne 0xa7d7
movq %rsi, %rdi
callq 0xadcc
movq %rax, %r15
movq (%r14), %rsi
testq %rsi, %rsi
je 0xa723
movq (%rsi), %rax
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq *(%rax)
movq (%r14), %rax
movq $0x0, (%r14)
movq %rax, 0x10(%rsp)
jmp 0xa72c
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xadea
movq (%r15), %rsi
leaq 0x18(%rsp), %rdi
callq 0xe973
movq (%r14), %rsi
testq %rsi, %rsi
je 0xa764
movq (%rsi), %rax
leaq 0x20(%rsp), %rdi
callq *(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x20(%rsp)
movq %rax, 0x8(%rsp)
jmp 0xa76d
movq $0x0, 0x10(%rsp)
leaq 0x28(%rsp), %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0xaee2
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0xae9e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xa759
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x10(%rsp)
jmp 0xa7cc
movq $0x0, 0x8(%rsp)
leaq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xa684
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xa78f
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xa7a8
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x18(%rsp)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa7cc
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7320
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x71b0
movq %rax, %r14
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x16b04(%rip), %rsi     # 0x212f8
leaq 0x16b18(%rip), %rdx     # 0x21313
leaq 0x48(%rsp), %rdi
callq 0xb2e0
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0xae24
xorl %ebp, %ebp
leaq 0x23532(%rip), %rsi     # 0x2dd50
leaq 0x649(%rip), %rdx       # 0xae6e
movq %r14, %rdi
callq 0x75f0
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xa84f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0xa84f
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0xa8da
movq %r14, %rdi
callq 0x7260
jmp 0xa8da
movq %rax, %rbx
jmp 0xa883
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xa87a
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xa893
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x18(%rsp)
jmp 0xa8a1
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa8da
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0xa8da
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xa8d1
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x7620
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/./cell.hpp
// Function: ALisp::ListTypeCell<std::vector<ALisp::Cell, std::allocator<ALisp::Cell>>, (ALisp::CellType)5>::IListTypeCell::add(ALisp::Cell const&)
void add(const Cell &other) EXCEPT final override {
				Cell to_add = other;
				if (other.type() != CellType::List) {
					to_add = ListTypeCell<ValueType, CellTypeType>();
					to_add.push(other);
				}
				_value.insert(_value.end(), to_add.cbegin(), to_add.cend());
			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
testq %rsi, %rsi
je 0xc83f
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rsp)
movq %rax, (%rsp)
jmp 0xc847
movq $0x0, (%rsp)
movq (%r14), %rax
testq %rax, %rax
je 0xc855
cmpl $0x5, 0x8(%rax)
je 0xc89d
movl $0x28, %edi
callq 0x7300
movl $0x5, 0x8(%rax)
leaq 0x2183b(%rip), %rcx     # 0x2e0a8
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq (%rsp), %rdi
movq %rax, (%rsp)
testq %rdi, %rdi
je 0xc892
movq (%rdi), %rax
callq *0x10(%rax)
movq %rsp, %rdi
movq %r14, %rsi
callq 0xd0d2
movq 0x18(%rbx), %r14
movq %rsp, %rdi
callq 0xd0ee
movq %rax, %r15
movq %rsp, %rdi
callq 0xd1ba
addq $0x10, %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0xd286
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc8d8
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r14
movq %rax, %rbx
jmp 0xc90b
jmp 0xc8ee
jmp 0xc8ee
movq %rdx, %r14
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc903
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, (%rsp)
movq %rbx, %rdi
testl %r14d, %r14d
jns 0xc918
callq 0x7470
callq 0x7620
nop
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/./cell.hpp
// Function: ALisp::ListTypeCell<std::vector<ALisp::Cell, std::allocator<ALisp::Cell>>, (ALisp::CellType)5>::IListTypeCell::equals(ALisp::Cell const&) const
bool equals(const Cell &other) const final override {
				if (type() != other.type()) return false;
				auto it1 = cbegin();
				auto it2 = other.cbegin();
				for (; it1 != cend() && it2 != cend(); ++it1, ++it2) {
					if (*it1 != *it2) return false;
				}
				return it1 == cend() && it2 == other.cend();
			}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movl 0x8(%rdi), %eax
movq (%rsi), %rcx
testq %rcx, %rcx
je 0xc93c
movl 0x8(%rcx), %ecx
jmp 0xc93e
xorl %ecx, %ecx
cmpl %ecx, %eax
jne 0xc99e
movq 0x10(%r15), %r12
movq %rbx, %rdi
callq 0xd0ee
movq %rax, %r14
movq 0x18(%r15), %rax
cmpq %rax, %r12
setne %cl
cmpq %rax, %r14
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xc999
movq (%r12), %rdi
testq %rdi, %rdi
je 0xc99e
cmpq %rdi, (%r14)
je 0xc983
movq (%rdi), %rax
movq %r14, %rsi
callq *0x78(%rax)
testb %al, %al
je 0xc99e
addq $0x8, %r12
addq $0x8, %r14
movq 0x18(%r15), %rax
cmpq %rax, %r12
je 0xc999
cmpq %rax, %r14
jne 0xc968
cmpq %rax, %r12
je 0xc9ac
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0xd1ba
cmpq %rax, %r14
sete %al
jmp 0xc9a0
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/./cell.hpp
// Function: ALisp::ListTypeCell<std::vector<ALisp::Cell, std::allocator<ALisp::Cell>>, (ALisp::CellType)5>::IListTypeCell::str_or_repr[abi:cxx11](bool) const
StringType str_or_repr(bool str) const {
				std::ostringstream ss;
				ss << stringOpen(str);
				for (auto it = _value.cbegin(); it != _value.cend(); ++it) {
					if (it != _value.cbegin())
						ss << " ";
					ss << (str ? it->str() : it->repr());
				}
				ss << stringClose();
				return ss.str();
			}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x74b0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xd020
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x73c0
movq %rbx, 0x28(%rsp)
leaq 0x18(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0xcebe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7320
movq 0x10(%r14), %r12
cmpq 0x18(%r14), %r12
je 0xcf3c
leaq 0x8(%rsp), %r13
leaq 0x30(%rsp), %rbx
cmpq 0x10(%r14), %r12
je 0xceec
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x14d98(%rip), %rsi     # 0x21c7f
callq 0x73c0
testb %bpl, %bpl
je 0xcefe
movq %r13, %rdi
movq %r12, %rsi
callq 0xadea
jmp 0xcf09
movq %r13, %rdi
movq %r12, %rsi
callq 0xd098
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x73c0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xcf32
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7320
addq $0x8, %r12
cmpq 0x18(%r14), %r12
jne 0xced2
movq %r15, 0x8(%rsp)
movw $0x29, 0x18(%rsp)
movq $0x1, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
movl $0x1, %edx
movq %r15, %rsi
callq 0x73c0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
movq 0x28(%rsp), %rbx
je 0xcf7f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7320
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x7570
movq 0x22025(%rip), %rsi     # 0x2efb8
leaq 0x30(%rsp), %rdi
callq 0x71e0
leaq 0xa0(%rsp), %rdi
callq 0x7120
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcfda
jmp 0xcfdf
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xcfec
jmp 0xcff9
jmp 0xcfda
jmp 0xcfda
movq %rax, %rbx
jmp 0xcff9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xcff9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7320
movq 0x21fb8(%rip), %rsi     # 0x2efb8
leaq 0x30(%rsp), %rdi
callq 0x71e0
leaq 0xa0(%rsp), %rdi
callq 0x7120
movq %rbx, %rdi
callq 0x7620
nop
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/./cell.hpp
// Function: ALisp::ListTypeCell<std::vector<ALisp::Cell, std::allocator<ALisp::Cell>>, (ALisp::CellType)5>::IListTypeCell::stringOpen[abi:cxx11](bool) const
StringType stringOpen(bool str_or_repr) const {
				switch (type()) {
					case CellType::Lambda: return "(#ref:lambda "; 
					case CellType::Macro: return "(#ref:macro "; 
					//case CellType::Tuple: return "(tuple ";
					default: return (str_or_repr ? "(" : "(list ");
				}
			}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rsi), %eax
cmpl $0x7, %eax
je 0xd048
cmpl $0x6, %eax
jne 0xd05f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x143fa(%rip), %rsi     # 0x21439
leaq 0x14400(%rip), %rdx     # 0x21446
jmp 0xd08b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x143f1(%rip), %rsi     # 0x21447
leaq 0x143f6(%rip), %rdx     # 0x21453
jmp 0xd08b
leaq 0x14abc(%rip), %rax     # 0x21b22
leaq 0x143e7(%rip), %rsi     # 0x21454
testb %dl, %dl
cmovneq %rax, %rsi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
xorb $0x1, %dl
movzbl %dl, %eax
leaq (%rax,%rax,4), %rax
leaq (%rsi,%rax), %rdx
incq %rdx
movq %rbx, %rdi
callq 0xb2e0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/./cell.hpp
// Function: ALisp::StringTypeCell<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, (ALisp::CellType)4>::IStringCell::integerValue() const
IntegerType integerValue() const EXCEPT final override {
				auto isInteger = tryStringToNumber<IntegerType>(_value);
				if (std::get<0>(isInteger))
					return std::get<1>(isInteger);
				else throw Exception("Failed to convert to integer: " + str());
			}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
leaq 0x10(%rdi), %rsi
movq %rsp, %rdi
callq 0xe05c
cmpb $0x1, 0x8(%rsp)
jne 0xda7f
movq (%rsp), %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x71b0
movq %rax, %rbx
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0xb250
leaq 0x139db(%rip), %rsi     # 0x2148d
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xe0f5
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xae24
xorl %ebp, %ebp
leaq 0x20276(%rip), %rsi     # 0x2dd50
leaq -0x2c73(%rip), %rdx     # 0xae6e
movq %rbx, %rdi
callq 0x75f0
movq %rdx, %r15
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdb15
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0xdb15
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0xdb37
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0xdb37
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xdb4c
movq %rbx, %rdi
callq 0x7260
jmp 0xdb4c
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
testl %r15d, %r15d
jns 0xdb59
callq 0x7470
callq 0x7620
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/./cell.hpp
// Function: ALisp::StringTypeCell<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, (ALisp::CellType)4>::IStringCell::floatValue() const
FloatType floatValue() const EXCEPT final override {
				auto isFloat = tryStringToNumber<FloatType>(_value);
				if (std::get<0>(isFloat))
					return std::get<1>(isFloat);
				else throw Exception("Failed to convert to float: " + str());
			}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
leaq 0x10(%rdi), %rsi
movq %rsp, %rdi
callq 0xe165
cmpb $0x1, 0x8(%rsp)
jne 0xdb92
movsd (%rsp), %xmm0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x71b0
movq %rax, %rbx
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0xb250
leaq 0x138e7(%rip), %rsi     # 0x214ac
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xe0f5
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xae24
xorl %ebp, %ebp
leaq 0x20163(%rip), %rsi     # 0x2dd50
leaq -0x2d86(%rip), %rdx     # 0xae6e
movq %rbx, %rdi
callq 0x75f0
movq %rdx, %r15
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdc28
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0xdc28
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0xdc4a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0xdc4a
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xdc5f
movq %rbx, %rdi
callq 0x7260
jmp 0xdc5f
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
testl %r15d, %r15d
jns 0xdc6c
callq 0x7470
callq 0x7620
nop
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/./cell.hpp
// Function: std::tuple<bool, long> ALisp::tryStringToNumber<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::tuple<bool, T> tryStringToNumber(const std::string &str) {
		T value;
		std::stringstream stream(str);
		stream >> value;
		return std::make_tuple(!stream.fail(), value);
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x7580
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x7330
leaq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x30(%rsp,%rax)
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
sete 0x8(%rbx)
movq 0x20edc(%rip), %rsi     # 0x2ef88
callq 0x7280
leaq 0x90(%rsp), %rdi
callq 0x7120
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x20eb2(%rip), %rsi     # 0x2ef88
leaq 0x10(%rsp), %rdi
callq 0x7280
leaq 0x90(%rsp), %rdi
callq 0x7120
movq %rbx, %rdi
callq 0x7620
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/atoms.cpp
// Function: ALisp::Atoms::ToString[abi:cxx11](unsigned long)
std::string ToString(AtomType id) EXCEPT {
			auto it = detail::atom_to_string.find(id);
			if (it != detail::atom_to_string.end())
				return it->second;
			throw Exception("atomid " + std::to_string(id) + " not found");
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x21537(%rip), %rdx     # 0x2f858
leaq 0x21528(%rip), %rax     # 0x2f850
movq %rax, %rcx
testq %rdx, %rdx
je 0xe34f
leaq 0x21519(%rip), %rcx     # 0x2f850
xorl %esi, %esi
cmpq %r14, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0xe337
movq %rax, %rdx
cmpq %rax, %rcx
je 0xe366
cmpq %r14, 0x20(%rcx)
leaq 0x214ee(%rip), %rdx     # 0x2f850
cmovbeq %rcx, %rdx
cmpq %rax, %rdx
je 0xe395
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x28(%rdx), %rsi
movq 0x30(%rdx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xb250
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x71b0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0xeb09
leaq 0x1331c(%rip), %rsi     # 0x216d2
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0xe0f5
leaq 0x1330e(%rip), %rsi     # 0x216da
leaq 0x40(%rsp), %rdi
callq 0x7670
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xe3f9
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0xe405
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xae24
xorl %ebp, %ebp
leaq 0x1f91d(%rip), %rsi     # 0x2dd50
leaq -0x35cc(%rip), %rdx     # 0xae6e
movq %rbx, %rdi
callq 0x75f0
movq %rdx, %r15
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xe469
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0xe469
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe48f
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0xe48f
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe4b5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0xe4b5
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xe4ca
movq %rbx, %rdi
callq 0x7260
jmp 0xe4ca
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
testl %r15d, %r15d
jns 0xe4d7
callq 0x7470
callq 0x7620
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/atoms.cpp
// Function: ALisp::Atoms::Get(unsigned long)
Cell Get(AtomType id) EXCEPT {
			auto it = detail::atom_to_cell.find(id);
			if (it == detail::atom_to_cell.end())
				throw Exception("atomid " + std::to_string(id) + " not found");
			return it->second;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x212fe(%rip), %rdx     # 0x2f8b8
leaq 0x212ef(%rip), %rax     # 0x2f8b0
movq %rax, %rcx
testq %rdx, %rdx
je 0xe5e8
leaq 0x212e0(%rip), %rcx     # 0x2f8b0
xorl %esi, %esi
cmpq %r14, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0xe5d0
movq %rax, %rdx
cmpq %rax, %rcx
je 0xe5ff
cmpq %r14, 0x20(%rcx)
leaq 0x212b5(%rip), %rdx     # 0x2f8b0
cmovbeq %rcx, %rdx
cmpq %rax, %rdx
je 0xe63f
movq 0x28(%rdx), %rsi
testq %rsi, %rsi
je 0xe628
movq (%rsi), %rax
movq %rsp, %rdi
callq *(%rax)
movq (%rsp), %rax
xorl %ecx, %ecx
movq %rcx, (%rsp)
movq %rax, (%rbx)
movq %rcx, (%rsp)
jmp 0xe62f
movq $0x0, (%rbx)
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x71b0
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0xeb09
leaq 0x13072(%rip), %rsi     # 0x216d2
movq %rsp, %rdi
leaq 0x40(%rsp), %rdx
callq 0xe0f5
leaq 0x13066(%rip), %rsi     # 0x216da
movq %rsp, %rdi
callq 0x7670
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xe69f
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0xe6ac
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xae24
xorl %ebp, %ebp
leaq 0x1f674(%rip), %rsi     # 0x2dd50
leaq -0x3875(%rip), %rdx     # 0xae6e
movq %rbx, %rdi
callq 0x75f0
movq %rdx, %r15
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xe713
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0xe713
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe739
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0xe739
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe75f
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0xe75f
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xe774
movq %rbx, %rdi
callq 0x7260
jmp 0xe774
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
testl %r15d, %r15d
jns 0xe781
callq 0x7470
callq 0x7620
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/atoms.cpp
// Function: ALisp::Atoms::Get(char const*)
Cell Get(const char *name) EXCEPT {
			auto it = detail::string_to_atom.find(StringType(name));
			if (it == detail::string_to_atom.end())
				throw Exception("atom " + StringType(name) + " not found");
			return Get(it->second);
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x7160
leaq 0x210c8(%rip), %rdi     # 0x2f878
leaq 0x8(%rsp), %rsi
callq 0xed6c
movq %rax, %r15
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0xe7d9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7320
leaq 0x210a0(%rip), %rax     # 0x2f880
cmpq %rax, %r15
je 0xe803
movq 0x40(%r15), %rsi
movq %rbx, %rdi
callq 0xe5a1
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x71b0
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x7160
leaq 0x12ebc(%rip), %rsi     # 0x216e5
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0xe0f5
leaq 0x12e9b(%rip), %rsi     # 0x216da
leaq 0x8(%rsp), %rdi
callq 0x7670
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xe86b
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0xe878
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xae24
xorl %ebp, %ebp
leaq 0x1f4a8(%rip), %rsi     # 0x2dd50
leaq -0x3a41(%rip), %rdx     # 0xae6e
movq %rbx, %rdi
callq 0x75f0
movq %rdx, %r15
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xe8df
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0xe8df
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe901
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0xe901
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe927
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0xe927
movq %rdx, %r15
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xe961
movq %rbx, %rdi
callq 0x7260
jmp 0xe961
jmp 0xe95b
movq %rdx, %r15
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe961
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0xe961
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
testl %r15d, %r15d
jns 0xe96e
callq 0x7470
callq 0x7620
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/atoms.cpp
// Function: ALisp::Atoms::Declare(char const*)
Cell Declare(const char *name) EXCEPT {
			if (Exists(name))
				return Get(name);
			AtomType id = detail::atom_counter++;
			AtomCell atom(id);
			detail::atom_to_cell.emplace(id, atom);
			detail::atom_to_string.emplace(id, StringType(name));
			detail::string_to_atom.emplace(StringType(name), id);
			return atom;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xe521
testb %al, %al
je 0xe99e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe786
jmp 0xea77
movq 0x20f33(%rip), %r15     # 0x2f8d8
leaq 0x1(%r15), %rax
movq %rax, 0x20f28(%rip)     # 0x2f8d8
movq %r15, 0x18(%rsp)
movl $0x18, %edi
callq 0x7300
movl $0x1, 0x8(%rax)
leaq 0x1f93b(%rip), %rcx     # 0x2e308
movq %rcx, (%rax)
movq %r15, 0x10(%rax)
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x20ec5(%rip), %rdi     # 0x2f8a8
leaq 0x18(%rsp), %rsi
callq 0xef38
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x7160
leaq 0x20e42(%rip), %rdi     # 0x2f848
leaq 0x18(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xf13c
leaq 0x30(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0xea30
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7320
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x7160
leaq 0x20e2f(%rip), %rdi     # 0x2f878
leaq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xf2d0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xea6f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7320
movq 0x10(%rsp), %rax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r14
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
jne 0xeaac
jmp 0xeac3
jmp 0xeabd
movq %rdx, %r14
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xeac3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0xeac3
jmp 0xeabd
movq %rdx, %r14
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xead3
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x10(%rsp)
jmp 0xeae6
jmp 0xeae0
movq %rdx, %r14
movq %rax, %rbx
movq %rbx, %rdi
testl %r14d, %r14d
jns 0xeaf3
callq 0x7470
callq 0x7620
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/contrib/linenoise-ng/src/ConvertUTF.cpp
// Function: linenoise_ng::isLegalUTF8Sequence(unsigned char const*, unsigned char const*)
Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) {
    int length = trailingBytesForUTF8[*source]+1;
    if (source+length > sourceEnd) {
        return false;
    }
    return isLegalUTF8(source, length);
}

// Assembly:
movq %rsi, %rax
movzbl (%rdi), %ecx
leaq 0x11d00(%rip), %rdx     # 0x21870
movsbq (%rcx,%rdx), %rsi
leaq (%rdi,%rsi), %rcx
incq %rcx
cmpq %rax, %rcx
jbe 0xfb84
xorl %eax, %eax
retq
incq %rsi
jmp 0xfb89
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/contrib/linenoise-ng/src/ConvertUTF.cpp
// Function: linenoise_ng::isLegalUTF8(unsigned char const*, int)
static Boolean isLegalUTF8(const UTF8 *source, int length) {
    UTF8 a;
    const UTF8 *srcptr = source+length;
    switch (length) {
    default: return false;
        /* Everything else falls through when "true"... */
    case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
    case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
    case 2: if ((a = (*--srcptr)) > 0xBF) return false;

        switch (*source) {
            /* no fall-through in this inner switch */
            case 0xE0: if (a < 0xA0) return false; break;
            case 0xED: if (a > 0x9F) return false; break;
            case 0xF0: if (a < 0x90) return false; break;
            case 0xF4: if (a > 0x8F) return false; break;
            default:   if (a < 0x80) return false;
        }

    case 1: if (*source >= 0x80 && *source < 0xC2) return false;
    }
    if (*source > 0xF4) return false;
    return true;
}

// Assembly:
leal -0x1(%rsi), %ecx
cmpl $0x3, %ecx
ja 0xfbcc
movslq %esi, %rax
addq %rdi, %rax
leaq 0x11c72(%rip), %rdx     # 0x21810
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movb (%rdi), %al
cmpb $-0x3e, %al
jl 0xfbcc
cmpb $-0xb, %al
setb %al
retq
cmpb $-0x41, -0x1(%rax)
jg 0xfbcc
decq %rax
cmpb $-0x41, -0x1(%rax)
jg 0xfbcc
decq %rax
movb -0x1(%rax), %al
cmpb $-0x41, %al
jbe 0xfbcf
xorl %eax, %eax
retq
movzbl (%rdi), %ecx
cmpl $0xef, %ecx
jg 0xfbf0
cmpl $0xe0, %ecx
je 0xfc0c
cmpl $0xed, %ecx
jne 0xfc06
cmpb $-0x61, %al
jbe 0xfba7
jmp 0xfbcc
cmpl $0xf0, %ecx
je 0xfc12
cmpl $0xf4, %ecx
jne 0xfc06
cmpb $-0x71, %al
jbe 0xfba7
jmp 0xfbcc
testb %al, %al
jns 0xfbcc
jmp 0xfba7
cmpb $-0x60, %al
jae 0xfba7
jmp 0xfbcc
cmpb $-0x70, %al
jae 0xfba7
jmp 0xfbcc
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: linenoiseHistoryFree
void linenoiseHistoryFree(void) {
  if (history) {
    for (int j = 0; j < historyLen; ++j) free(history[j]);
    historyLen = 0;
    free(history);
    history = 0;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x1f87c(%rip), %rbx     # 0x2f960
testq %rbx, %rbx
je 0x10126
movslq 0x1f878(%rip), %r14     # 0x2f968
testq %r14, %r14
jle 0x10109
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x7400
incq %r15
cmpq %r15, %r14
jne 0x100f8
movl $0x0, 0x1f855(%rip)     # 0x2f968
movq %rbx, %rdi
callq 0x7400
movq $0x0, 0x1f83a(%rip) # 0x2f960
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: write32(int, char32_t*, int)
static int write32(int fd, char32_t* text32, int len32) {
#ifdef _WIN32
  if (isatty(fd)) {
    size_t len16 = 2 * len32 + 1;
    unique_ptr<char16_t[]> text16(new char16_t[len16]);
    size_t count16 = WinWrite32(text16.get(), text32, len32);

    return static_cast<int>(count16);
  } else {
    size_t len8 = 4 * len32 + 1;
    unique_ptr<char[]> text8(new char[len8]);
    size_t count8 = 0;

    copyString32to8(text8.get(), len8, &count8, text32, len32);

    return write(fd, text8.get(), static_cast<unsigned int>(count8));
  }
#else
  size_t len8 = 4 * len32 + 1;
  unique_ptr<char[]> text8(new char[len8]);
  size_t count8 = 0;

  copyString32to8(text8.get(), len8, &count8, text32, len32);

  return write(fd, text8.get(), count8);
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %r15
leal 0x1(,%r14,4), %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0x7030
movq %rax, %rbx
movq %rsp, %rdx
movq $0x0, (%rdx)
movslq %r14d, %r8
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x13dfb
movq (%rsp), %rdx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x7130
movq %rax, %r14
movq %rbx, %rdi
callq 0x7480
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7480
movq %r14, %rdi
callq 0x7620
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: cleanupCtrl(int)
static int cleanupCtrl(int c) {
  if (c & CTRL) {
    int d = c & 0x1FF;
    if (d >= 'a' && d <= 'z') {
      c = (c + ('a' - ctrlChar('A'))) & ~CTRL;
    }
    if (d >= 'A' && d <= 'Z') {
      c = (c + ('A' - ctrlChar('A'))) & ~CTRL;
    }
    if (d >= ctrlChar('A') && d <= ctrlChar('Z')) {
      c = c & ~CTRL;
    }
  }
  return c;
}

// Assembly:
movl %edi, %eax
btl $0x1d, %edi
jae 0x11187
movl %eax, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
leal -0x61(%rcx), %edx
leal 0x60(%rax), %esi
movl $0xdfffffff, %edi       # imm = 0xDFFFFFFF
andl %edi, %esi
cmpl $0x1a, %edx
cmovael %eax, %esi
leal -0x41(%rcx), %eax
leal 0x40(%rsi), %edx
andl %edi, %edx
cmpl $0x1a, %eax
cmovael %esi, %edx
decl %ecx
andl %edx, %edi
cmpl $0x1a, %ecx
cmovael %edx, %edi
movl %edi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: InputBuffer::clearScreen(PromptBase&)
void InputBuffer::clearScreen(PromptBase& pi) {
  linenoiseClearScreen();
  if (!pi.write()) return;
#ifndef _WIN32
  // we have to generate our own newline on line wrap on Linux
  if (pi.promptIndentation == 0 && pi.promptExtraLines > 0)
    if (write(1, "\n", 1) == -1) return;
#endif
  pi.promptCursorRowOffset = pi.promptExtraLines;
  refreshLine(pi);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x109ca(%rip), %rsi     # 0x21b79
movl $0x7, %edx
movl $0x1, %edi
callq 0x7130
movq 0x8(%rbx), %rdi
movl 0x1c(%rbx), %esi
callq 0x10581
cmpl $-0x1, %eax
je 0x1120f
cmpl $0x0, 0x24(%rbx)
jne 0x111f7
cmpl $0x0, 0x20(%rbx)
jle 0x111f7
leaq 0x10a44(%rip), %rsi     # 0x21c26
movl $0x1, %edx
movl $0x1, %edi
callq 0x7130
cmpq $-0x1, %rax
je 0x1120f
movl 0x20(%rbx), %eax
movl %eax, 0x30(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1012c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: linenoiseHistoryAdd
int linenoiseHistoryAdd(const char* line) {
  if (historyMaxLen == 0) {
    return 0;
  }
  if (history == NULL) {
    history =
        reinterpret_cast<char8_t**>(malloc(sizeof(char8_t*) * historyMaxLen));
    if (history == NULL) {
      return 0;
    }
    memset(history, 0, (sizeof(char*) * historyMaxLen));
  }
  char8_t* linecopy = strdup8(line);
  if (!linecopy) {
    return 0;
  }

  // convert newlines in multi-line code to spaces before storing
  char8_t* p = linecopy;
  while (*p) {
    if (*p == '\n') {
      *p = ' ';
    }
    ++p;
  }

  // prevent duplicate history entries
  if (historyLen > 0 && history[historyLen - 1] != nullptr &&
      strcmp(reinterpret_cast<char const*>(history[historyLen - 1]),
             reinterpret_cast<char const*>(linecopy)) == 0) {
    free(linecopy);
    return 0;
  }

  if (historyLen == historyMaxLen) {
    free(history[0]);
    memmove(history, history + 1, sizeof(char*) * (historyMaxLen - 1));
    --historyLen;
    if (--historyPreviousIndex < -1) {
      historyPreviousIndex = -2;
    }
  }

  history[historyLen] = linecopy;
  ++historyLen;
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl 0x1bf5e(%rip), %ebx     # 0x2f374
cmpq $0x0, 0x1c542(%rip)     # 0x2f960
jne 0x1344d
leaq (,%rbx,8), %r15
movq %r15, %rdi
callq 0x74a0
movq %rax, 0x1c529(%rip)     # 0x2f960
testq %rax, %rax
je 0x13510
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x7200
movq %r14, %rdi
callq 0x7650
xorl %ebp, %ebp
testq %rax, %rax
je 0x1351c
movq %rax, %r14
movzbl (%rax), %ecx
cmpl $0xa, %ecx
je 0x13471
testl %ecx, %ecx
jne 0x13474
jmp 0x13479
movb $0x20, (%rax)
incq %rax
jmp 0x13463
movslq 0x1c4e8(%rip), %r12     # 0x2f968
testq %r12, %r12
jle 0x134a2
movq 0x1c4d4(%rip), %rax     # 0x2f960
movq -0x8(%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x134a2
movq %r14, %rsi
callq 0x74d0
testl %eax, %eax
je 0x13514
cmpl %ebx, %r12d
jne 0x134ee
movq 0x1c4b2(%rip), %r15     # 0x2f960
movq (%r15), %rdi
callq 0x7400
leaq 0x8(%r15), %rsi
decl %ebx
shlq $0x3, %rbx
movq %r15, %rdi
movq %rbx, %rdx
callq 0x75b0
decl %r12d
movl %r12d, 0x1c493(%rip)    # 0x2f968
movl 0x1be95(%rip), %eax     # 0x2f370
leal -0x1(%rax), %ecx
testl %eax, %eax
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmovnsl %ecx, %eax
movl %eax, 0x1be82(%rip)     # 0x2f370
movq 0x1c46b(%rip), %rax     # 0x2f960
movslq 0x1c46c(%rip), %rcx     # 0x2f968
movq %r14, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x1c45f(%rip)     # 0x2f968
movl $0x1, %ebp
jmp 0x1351c
xorl %ebp, %ebp
jmp 0x1351c
movq %r14, %rdi
callq 0x7400
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: linenoiseHistorySetMaxLen
int linenoiseHistorySetMaxLen(int len) {
  if (len < 1) {
    return 0;
  }
  if (history) {
    int tocopy = historyLen;
    char8_t** newHistory =
        reinterpret_cast<char8_t**>(malloc(sizeof(char8_t*) * len));
    if (newHistory == NULL) {
      return 0;
    }
    if (len < tocopy) {
      tocopy = len;
    }
    memcpy(newHistory, history + historyMaxLen - tocopy,
           sizeof(char8_t*) * tocopy);
    free(history);
    history = newHistory;
  }
  historyMaxLen = len;
  if (historyLen > historyMaxLen) {
    historyLen = historyMaxLen;
  }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebp, %ebp
testl %edi, %edi
jle 0x13af4
movl %edi, %ebx
movq 0x1bed6(%rip), %r14     # 0x2f960
testq %r14, %r14
je 0x13adb
movl 0x1bed2(%rip), %r12d    # 0x2f968
movl %ebx, %edi
shlq $0x3, %rdi
callq 0x74a0
testq %rax, %rax
je 0x13af4
movq %rax, %r15
cmpl %ebx, %r12d
cmovgel %ebx, %r12d
movl 0x1b8be(%rip), %eax     # 0x2f374
leaq (%r14,%rax,8), %rsi
movslq %r12d, %rdx
shlq $0x3, %rdx
subq %rdx, %rsi
movq %r15, %rdi
callq 0x72a0
movq %r14, %rdi
callq 0x7400
movq %r15, 0x1be85(%rip)     # 0x2f960
movl %ebx, 0x1b893(%rip)     # 0x2f374
movl $0x1, %ebp
cmpl %ebx, 0x1be7c(%rip)     # 0x2f968
jle 0x13af4
movl %ebx, 0x1be74(%rip)     # 0x2f968
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: linenoiseHistorySave
int linenoiseHistorySave(const char* filename) {
#if _WIN32
  FILE* fp = fopen(filename, "wt");
#else
  int fd = open(filename, O_CREAT | O_TRUNC | O_WRONLY, S_IRUSR | S_IWUSR);

  if (fd < 0) {
    return -1;
  }

  FILE* fp = fdopen(fd, "wt");
#endif

  if (fp == NULL) {
    return -1;
  }

  for (int j = 0; j < historyLen; ++j) {
    if (history[j][0] != '\0') {
      fprintf(fp, "%s\n", history[j]);
    }
  }

  fclose(fp);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x241, %esi            # imm = 0x241
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x7270
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x13ba0
leaq 0xe0b5(%rip), %rsi      # 0x21bfd
movl %eax, %edi
callq 0x7370
testq %rax, %rax
je 0x13ba0
movq %rax, %rbx
cmpl $0x0, 0x1be0a(%rip)     # 0x2f968
jle 0x13b96
leaq 0xe099(%rip), %r14      # 0x21c00
xorl %r15d, %r15d
movq 0x1bdef(%rip), %rax     # 0x2f960
movq (%rax,%r15,8), %rdx
cmpb $0x0, (%rdx)
je 0x13b87
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x74f0
incq %r15
movslq 0x1bdd7(%rip), %rax     # 0x2f968
cmpq %rax, %r15
jl 0x13b6a
movq %rbx, %rdi
callq 0x72f0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq