LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: readUnicodeCharacter()
static char32_t readUnicodeCharacter(void) {
  static char8_t utf8String[5];
  static size_t utf8Count = 0;
  while (true) {
    char8_t c;

    /* Continue reading if interrupted by signal. */
    ssize_t nread;
    do {
      nread = read(0, &c, 1);
    } while ((nread == -1) && (errno == EINTR));

    if (nread <= 0) return 0;
    if (c <= 0x7F) {  // short circuit ASCII
      utf8Count = 0;
      return c;
    } else if (utf8Count < sizeof(utf8String) - 1) {
      utf8String[utf8Count++] = c;
      utf8String[utf8Count] = 0;
      char32_t unicodeChar[2];
      size_t ucharCount;
      ConversionResult res =
          copyString8to32(unicodeChar, 2, ucharCount, utf8String);
      if (res == conversionOK && ucharCount) {
        utf8Count = 0;
        return unicodeChar[0];
      }
    } else {
      utf8Count =
          0;  // this shouldn't happen: got four bytes but no UTF-8 character
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
jmp 0x2325a
xorl %edi, %edi
leaq -0x5(%rbp), %rsi
movl $0x1, %edx
callq 0x8660
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $-0x1, -0x10(%rbp)
movb %al, -0x25(%rbp)
jne 0x23288
callq 0x8070
cmpl $0x4, (%rax)
sete %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x2325a
cmpq $0x0, -0x10(%rbp)
jg 0x232a2
movl $0x0, -0x4(%rbp)
jmp 0x23350
movzbl -0x5(%rbp), %eax
cmpl $0x7f, %eax
jg 0x232c2
movq $0x0, 0x34852(%rip) # 0x57b08
movzbl -0x5(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x23350
cmpq $0x4, 0x3483e(%rip)     # 0x57b08
jae 0x2333e
movb -0x5(%rbp), %dl
movq 0x34832(%rip), %rcx     # 0x57b08
movq %rcx, %rax
addq $0x1, %rax
movq %rax, 0x34824(%rip)     # 0x57b08
leaq 0x34811(%rip), %rax     # 0x57afc
movb %dl, (%rax,%rcx)
movq 0x34813(%rip), %rcx     # 0x57b08
leaq 0x34800(%rip), %rax     # 0x57afc
movb $0x0, (%rax,%rcx)
leaq -0x18(%rbp), %rdi
movl $0x2, %esi
leaq -0x20(%rbp), %rdx
leaq 0x347e8(%rip), %rcx     # 0x57afc
callq 0x1ffe0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x2333c
cmpq $0x0, -0x20(%rbp)
je 0x2333c
movq $0x0, 0x347d4(%rip) # 0x57b08
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x23350
jmp 0x23349
movq $0x0, 0x347bf(%rip) # 0x57b08
jmp 0x2334b
jmp 0x23258
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: EscapeSequenceProcessing::doDispatch(char32_t, EscapeSequenceProcessing::CharacterDispatch&)
static char32_t doDispatch(char32_t c, CharacterDispatch& dispatchTable) {
  for (unsigned int i = 0; i < dispatchTable.len; ++i) {
    if (static_cast<unsigned char>(dispatchTable.chars[i]) == c) {
      return dispatchTable.dispatch[i](c);
    }
  }
  return dispatchTable.dispatch[dispatchTable.len](c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x233bb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cmpl -0x8(%rbp), %eax
jne 0x233ae
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x8(%rbp), %edi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x233d5
jmp 0x233b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x23376
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movl -0x8(%rbp), %edi
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: EscapeSequenceProcessing::setMetaRoutine(char32_t)
static char32_t setMetaRoutine(char32_t c) {
  thisKeyMetaCtrl = META;
  if (c == 0x1B) {  // another ESC, stay in ESC processing mode
    c = readUnicodeCharacter();
    if (c == 0) return 0;
    return doDispatch(c, escDispatch);
  }
  return doDispatch(c, initialDispatch);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl $0x40000000, 0x34603(%rip) # imm = 0x40000000
cmpl $0x1b, -0x8(%rbp)
jne 0x23526
callq 0x23250
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x23512
movl $0x0, -0x4(%rbp)
jmp 0x23538
movl -0x8(%rbp), %edi
leaq 0x33f8c(%rip), %rsi     # 0x574a8
callq 0x23360
movl %eax, -0x4(%rbp)
jmp 0x23538
movl -0x8(%rbp), %edi
leaq 0x33f48(%rip), %rsi     # 0x57478
callq 0x23360
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: EscapeSequenceProcessing::escLeftBracket1Semicolon3Routine(char32_t)
static char32_t escLeftBracket1Semicolon3Routine(char32_t c) {
  c = readUnicodeCharacter();
  if (c == 0) return 0;
  thisKeyMetaCtrl |= META;
  return doDispatch(c, escLeftBracket1Semicolon3or5Dispatch);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
callq 0x23250
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x238b2
movl $0x0, -0x4(%rbp)
jmp 0x238d5
movl 0x34240(%rip), %eax     # 0x57af8
orl $0x40000000, %eax       # imm = 0x40000000
movl %eax, 0x34235(%rip)     # 0x57af8
movl -0x8(%rbp), %edi
leaq 0x33d0b(%rip), %rsi     # 0x575d8
callq 0x23360
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: EscapeSequenceProcessing::escLeftBracket1Semicolon5Routine(char32_t)
static char32_t escLeftBracket1Semicolon5Routine(char32_t c) {
  c = readUnicodeCharacter();
  if (c == 0) return 0;
  thisKeyMetaCtrl |= CTRL;
  return doDispatch(c, escLeftBracket1Semicolon3or5Dispatch);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
callq 0x23250
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x23902
movl $0x0, -0x4(%rbp)
jmp 0x23925
movl 0x341f0(%rip), %eax     # 0x57af8
orl $0x20000000, %eax       # imm = 0x20000000
movl %eax, 0x341e5(%rip)     # 0x57af8
movl -0x8(%rbp), %edi
leaq 0x33cbb(%rip), %rsi     # 0x575d8
callq 0x23360
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: strlen32(char32_t const*)
static size_t strlen32(const char32_t* str) {
  const char32_t* ptr = str;

  while (*ptr) {
    ++ptr;
  }

  return ptr - str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x23a37
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x23a20
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: Utf32String::Utf32String(char const*)
explicit Utf32String(const char* src) : _length(0), _data(nullptr) {
    size_t len = strlen(src);
    // note: parens intentional, _data must be properly initialized
    _data = new char32_t[len + 1]();
    copyString8to32(_data, len + 1, _length, src);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x8210
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x30(%rbp)
callq 0x8040
movq -0x30(%rbp), %rdx
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
callq 0x8270
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdx
movq %rax, 0x8(%rdx)
movq 0x8(%rdx), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
movq -0x10(%rbp), %rcx
callq 0x230f0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: DynamicPrompt::updateSearchText(char32_t const*)
void updateSearchText(const char32_t* textPtr) {
    Utf32String tempUnicode(textPtr);
    searchTextLen = static_cast<int>(tempUnicode.chars());
    searchText = tempUnicode;
    updateSearchPrompt();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x25910
movq -0x40(%rbp), %rdi
callq 0x259d0
movq %rax, -0x38(%rbp)
jmp 0x242f8
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rax
movl %eax, 0x58(%rdi)
addq $0x40, %rdi
leaq -0x20(%rbp), %rsi
callq 0x24640
jmp 0x24312
movq -0x48(%rbp), %rdi
callq 0x24350
jmp 0x2431d
leaq -0x20(%rbp), %rdi
callq 0x23b50
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x23b50
movq -0x28(%rbp), %rdi
callq 0x87b0
nopw (%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: DynamicPrompt::updateSearchPrompt()
void updateSearchPrompt(void) {
    const Utf32String* basePrompt =
        (direction > 0) ? &forwardSearchBasePrompt : &reverseSearchBasePrompt;
    size_t promptStartLength = basePrompt->length();
    promptChars = static_cast<int>(promptStartLength + searchTextLen +
                                   endSearchBasePrompt.length());
    promptBytes = promptChars;
    Utf32String tempUnicode(promptChars + 1);
    memcpy(tempUnicode.get(), basePrompt->get(),
           sizeof(char32_t) * promptStartLength);
    memcpy(&tempUnicode[promptStartLength], searchText.get(),
           sizeof(char32_t) * searchTextLen);
    size_t endIndex = promptStartLength + searchTextLen;
    memcpy(&tempUnicode[endIndex], endSearchBasePrompt.get(),
           sizeof(char32_t) * (endSearchBasePrompt.length() + 1));
    tempUnicode.initFromBuffer();
    promptText = tempUnicode;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl 0x5c(%rax), %eax
testl %eax, %eax
leaq 0x3369d(%rip), %rcx     # 0x57a10
leaq 0x336a6(%rip), %rax     # 0x57a20
cmovgq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x23df0
movq -0x68(%rbp), %rcx
movq %rax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl 0x58(%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x7c(%rbp)
leaq 0x3368b(%rip), %rdi     # 0x57a30
movq %rdi, -0x60(%rbp)
callq 0x23df0
movl -0x7c(%rbp), %ecx
movq %rax, %rdx
movq -0x68(%rbp), %rax
addl %edx, %ecx
movl %ecx, 0x18(%rax)
movl 0x18(%rax), %ecx
movl %ecx, 0x1c(%rax)
movl 0x18(%rax), %esi
incl %esi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x23e40
movq -0x48(%rbp), %rdi
callq 0x23ec0
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x23ec0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
shlq $0x2, %rdx
callq 0x8360
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x23e10
movq -0x68(%rbp), %rdi
movq %rax, -0x70(%rbp)
addq $0x40, %rdi
callq 0x23ec0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
movq -0x68(%rbp), %rax
movslq 0x58(%rax), %rdx
shlq $0x2, %rdx
callq 0x8360
movq -0x68(%rbp), %rcx
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq 0x58(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x23e10
movq -0x60(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x23ec0
movq -0x60(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x23df0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq 0x4(,%rax,4), %rdx
callq 0x8360
movq -0x48(%rbp), %rdi
callq 0x24600
jmp 0x2448f
movq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x24640
jmp 0x2449e
leaq -0x28(%rbp), %rdi
callq 0x23b50
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x23b50
movq -0x38(%rbp), %rdi
callq 0x87b0
nop
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: Utf32String::operator=(Utf32String const&)
Utf32String& operator=(const Utf32String& that) {
    if (this != &that) {
      delete[] _data;
      _data = new char32_t[that._length]();
      _length = that._length;
      memcpy(_data, that._data, sizeof(char32_t) * _length);
    }

    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x246e9
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2467d
movq -0x20(%rbp), %rdi
callq 0x85a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x30(%rbp)
callq 0x8040
movq -0x30(%rbp), %rdx
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
callq 0x8270
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq (%rax), %rdx
shlq $0x2, %rdx
callq 0x8360
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: KillRing::yankPop()
Utf32String* yankPop() {
    if (size == 0) {
      return 0;
    }
    ++index;
    if (index == size) {
      index = 0;
    }
    return &theRing[indexToSlot[index]];
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, (%rax)
jne 0x24a93
movq $0x0, -0x8(%rbp)
jmp 0x24ad0
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x4(%rcx)
movl 0x4(%rcx), %eax
cmpl (%rcx), %eax
jne 0x24ab2
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movslq 0x4(%rax), %rcx
movsbq 0x8(%rax,%rcx), %rsi
callq 0x23dd0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: InputBuffer::preloadBuffer(char const*)
void preloadBuffer(const char* preloadText) {
    size_t ucharCount = 0;
    copyString8to32(buf32, buflen + 1, ucharCount, preloadText);
    recomputeCharacterWidths(buf32, charWidths, static_cast<int>(ucharCount));
    len = static_cast<int>(ucharCount);
    pos = static_cast<int>(ucharCount);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq (%rax), %rdi
movl 0x10(%rax), %eax
addl $0x1, %eax
movslq %eax, %rsi
movq -0x10(%rbp), %rcx
leaq -0x18(%rbp), %rdx
callq 0x230f0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movl %eax, %edx
callq 0x23a60
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rcx
movl %ecx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: Utf32String::Utf32String(char32_t const*)
explicit Utf32String(const char32_t* src) : _length(0), _data(nullptr) {
    for (_length = 0; src[_length] != 0; ++_length) {
    }

    // note: parens intentional, _data must be properly initialized
    _data = new char32_t[_length + 1]();
    memcpy(_data, src, _length * sizeof(char32_t));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rcx), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x25961
jmp 0x25951
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x2593e
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x1, %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x28(%rbp)
callq 0x8040
movq -0x28(%rbp), %rdx
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
xorl %esi, %esi
callq 0x8270
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq (%rax), %rdx
shlq $0x2, %rdx
callq 0x8360
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/wcwidth.cpp
// Function: linenoise_ng::bisearch(char32_t, linenoise_ng::interval const*, int)
static int bisearch(char32_t ucs, const struct interval *table, int max) {
  int min = 0;
  int mid;

  if (ucs < table[0].first || ucs > table[max].last)
    return 0;
  while (max >= min) {
    mid = (min + max) / 2;
    if (ucs > table[mid].last)
      min = mid + 1;
    else if (ucs < table[mid].first)
      max = mid - 1;
    else
      return 1;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x26b71
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
cmpl 0x4(%rcx,%rdx,8), %eax
jbe 0x26b7a
movl $0x0, -0x4(%rbp)
jmp 0x26be0
jmp 0x26b7c
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x26bd9
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
cmpl 0x4(%rcx,%rdx,8), %eax
jbe 0x26bb1
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x26bd7
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,8), %eax
jae 0x26bcc
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x26bd5
movl $0x1, -0x4(%rbp)
jmp 0x26be0
jmp 0x26bd7
jmp 0x26b7c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/wcwidth.cpp
// Function: linenoise_ng::mk_wcswidth(char32_t const*, unsigned long)
int mk_wcswidth(const char32_t* pwcs, size_t n)
{
  int w, width = 0;

  for (;*pwcs && n-- > 0; pwcs++)
    if ((w = mk_wcwidth(*pwcs)) < 0)
      return -1;
    else
      width += w;

  return width;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x21(%rbp)
je 0x26c2e
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
seta %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x26c37
jmp 0x26c6c
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x26980
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x26c53
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26c72
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x26c5e
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x26c07
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: andrakis[P]alisp/contrib/linenoise-ng/src/wcwidth.cpp
// Function: linenoise_ng::mk_wcswidth_cjk(wchar_t const*, unsigned long)
int mk_wcswidth_cjk(const wchar_t *pwcs, size_t n)
{
  int w, width = 0;

  for (;*pwcs && n-- > 0; pwcs++)
    if ((w = mk_wcwidth_cjk(*pwcs)) < 0)
      return -1;
    else
      width += w;

  return width;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x21(%rbp)
je 0x26d0e
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
seta %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x26d17
jmp 0x26d4c
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x26c80
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x26d33
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26d52
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x26d3e
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x26ce7
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: andrakis[P]alisp/./environment.hpp
// Function: ALisp::Environment::get(unsigned long)
Cell get(key_type key) EXCEPT {
			auto it = find_key(key);
			if (it != cend())
				return it->second;
			else if (has_parent())
				return _outer->get(key);
			throw KeyNotFoundException(key);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x18(%rbp), %rsi
callq 0x289d0
movq %rax, -0x40(%rbp)
jmp 0x28346
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x28a30
movq %rax, -0x60(%rbp)
jmp 0x2835d
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x28a00
testb $0x1, %al
jne 0x28378
jmp 0x283a9
leaq -0x20(%rbp), %rdi
callq 0x28a60
movq -0x58(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0xb900
jmp 0x28393
jmp 0x2843f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x28430
movq -0x48(%rbp), %rdi
callq 0x17840
movb %al, -0x61(%rbp)
jmp 0x283b7
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x283c0
jmp 0x283e1
movq -0x48(%rbp), %rdi
addq $0x38, %rdi
callq 0xba80
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x28310
jmp 0x283df
jmp 0x2843f
jmp 0x283e3
movl $0x28, %edi
callq 0x8240
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rsi
callq 0x28a90
jmp 0x28402
movq -0x70(%rbp), %rdi
leaq 0x2e043(%rip), %rsi     # 0x56450
leaq 0x72c(%rip), %rdx       # 0x28b40
callq 0x8770
jmp 0x28452
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8300
cmpl $0x0, -0x2c(%rbp)
jge 0x28449
movq -0x28(%rbp), %rdi
callq 0x8590
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x87b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: andrakis[P]alisp/./environment.hpp
// Function: ALisp::Environment::set(unsigned long, ALisp::Cell)
void set(key_type key, val_type val) EXCEPT {
			// Note function signature: val is copied not referenced
			if (has_key(key)) create(key, val);
			else if (has_parent()) _outer->set(key, val);
			else throw KeyNotFoundException(key);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x10(%rbp), %rsi
callq 0x28cc0
movb %al, -0x39(%rbp)
jmp 0x2848e
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x28497
jmp 0x284fa
movq -0x50(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xb900
jmp 0x284ae
movq -0x58(%rbp), %rsi
movq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0xd3f0
jmp 0x284c1
leaq -0x30(%rbp), %rdi
callq 0xb9d0
jmp 0x285c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x285b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xb9d0
jmp 0x285b3
movq -0x48(%rbp), %rdi
callq 0x17840
testb $0x1, %al
jne 0x28509
jmp 0x28566
movq -0x48(%rbp), %rdi
addq $0x38, %rdi
callq 0xba80
movq -0x50(%rbp), %rsi
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xb900
jmp 0x28531
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x28460
jmp 0x28544
leaq -0x38(%rbp), %rdi
callq 0xb9d0
jmp 0x285c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xb9d0
jmp 0x285b3
movl $0x28, %edi
callq 0x8240
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rsi
callq 0x28a90
jmp 0x28585
movq -0x70(%rbp), %rdi
leaq 0x2dec0(%rip), %rsi     # 0x56450
leaq 0x5a9(%rip), %rdx       # 0x28b40
callq 0x8770
jmp 0x285d3
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x8300
cmpl $0x0, -0x24(%rbp)
jge 0x285ca
movq -0x20(%rbp), %rdi
callq 0x8590
jmp 0x285c4
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x87b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: andrakis[P]alisp/./environment.hpp
// Function: ALisp::Environment::addRange(std::vector<ALisp::Cell, std::allocator<ALisp::Cell>> const&, std::vector<ALisp::Cell, std::allocator<ALisp::Cell>> const&)
void addRange(const ListType &keys, const ListType &values) {
			for (auto it1 = keys.cbegin(), it2 = values.cbegin();
				 it1 != keys.cend() && it2 != values.cend();
				 ++it1, ++it2) {
				create(it1->atomId(), *it2);
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12f00
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12f00
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12f30
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x12d80
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x59(%rbp)
jne 0x2c53e
jmp 0x2c55b
movq -0x18(%rbp), %rdi
callq 0x12f30
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x12d80
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x2c564
jmp 0x2c5dc
leaq -0x20(%rbp), %rdi
callq 0x13690
movq %rax, %rdi
callq 0xd430
movq %rax, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x12df0
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xb900
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0xd3f0
jmp 0x2c5a5
leaq -0x40(%rbp), %rdi
callq 0xb9d0
leaq -0x20(%rbp), %rdi
callq 0x12e10
leaq -0x28(%rbp), %rdi
callq 0x12e10
jmp 0x2c516
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xb9d0
jmp 0x2c5e2
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x87b0
nopl (%rax,%rax)
// File: andrakis[P]alisp/parser.cpp
// Function: ALisp::Parser::detail::atom(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Cell atom(const TokenType &token) EXCEPT {
				if (startOf(token) == '"' && endOf(token) == '"')
					return StringCell(token.substr(1, token.length() - 2));
				if (isdigit(token[0]) || (token[0] == '-' && isdigit(token[1]))) {
					// Number
					auto isInteger = tryStringToNumber<IntegerType>(token);
					if (std::get<0>(isInteger))
						return IntCell(std::get<1>(isInteger));
					auto isFloat = tryStringToNumber<FloatType>(token);
					if (std::get<0>(isFloat))
						return FloatCell(std::get<1>(isFloat));
				}
				return Atoms::Declare(token.c_str());
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2c5f0
movsbl %al, %eax
cmpl $0x22, %eax
jne 0x2cc05
movq -0x10(%rbp), %rdi
callq 0x2c620
movsbl %al, %eax
cmpl $0x22, %eax
jne 0x2cc05
movq -0x10(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x8680
movq -0x90(%rbp), %rsi
movq %rax, %rcx
addq $-0x2, %rcx
leaq -0x38(%rbp), %rdi
movl $0x1, %edx
callq 0x8440
jmp 0x2cb99
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xbe50
jmp 0x2cba8
movq -0x88(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xbd50
leaq -0x18(%rbp), %rdi
callq 0xbeb0
leaq -0x38(%rbp), %rdi
callq 0x8878
jmp 0x2cd14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2cbf2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8878
cmpl $0x0, -0x44(%rbp)
jge 0x2cd21
movq -0x40(%rbp), %rdi
callq 0x8590
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x84c0
movsbl (%rax), %edi
callq 0x83a0
cmpl $0x0, %eax
jne 0x2cc57
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x84c0
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x2ccf8
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x84c0
movsbl (%rax), %edi
callq 0x83a0
cmpl $0x0, %eax
je 0x2ccf8
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x16550
jmp 0x2cc66
leaq -0x58(%rbp), %rdi
callq 0x16650
testb $0x1, (%rax)
je 0x2cca6
leaq -0x58(%rbp), %rdi
callq 0x16670
movq (%rax), %rsi
leaq -0x60(%rbp), %rdi
callq 0x2d380
jmp 0x2cc8b
movq -0x88(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xbd50
leaq -0x60(%rbp), %rdi
callq 0x2d3e0
jmp 0x2cd14
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x168d0
jmp 0x2ccb5
leaq -0x70(%rbp), %rdi
callq 0x169d0
testb $0x1, (%rax)
je 0x2ccf6
leaq -0x70(%rbp), %rdi
callq 0x169f0
movsd (%rax), %xmm0
leaq -0x78(%rbp), %rdi
callq 0x2d400
jmp 0x2ccdb
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xbd50
leaq -0x78(%rbp), %rdi
callq 0x2d460
jmp 0x2cd14
jmp 0x2ccf8
movq -0x10(%rbp), %rdi
callq 0x81e0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x17fe0
jmp 0x2cd12
jmp 0x2cd14
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x87b0
nopw (%rax,%rax)
// File: andrakis[P]alisp/./cell.hpp
// Function: ALisp::MathematicalCell<long, (ALisp::CellType)2>::IMathematicalCell::convertOther(ALisp::Cell const&) const
ValueType convertOther(const Cell &other) const EXCEPT {
				switch (other.type()) {
					case CellType::Integer: return (ValueType)other.integerValue();
					case CellType::Float: return (ValueType)other.floatValue();
					default:
						throw Exception("Unable to convert other");
				}
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd3a0
movl %eax, -0x50(%rbp)
jmp 0x2e74e
movl -0x50(%rbp), %eax
subl $0x2, %eax
je 0x2e773
jmp 0x2e758
movl -0x50(%rbp), %eax
subl $0x3, %eax
je 0x2e78f
jmp 0x2e7b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2e852
movq -0x18(%rbp), %rdi
callq 0x2e880
movq %rax, -0x58(%rbp)
jmp 0x2e782
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2e861
movq -0x18(%rbp), %rdi
callq 0x2e900
movsd %xmm0, -0x60(%rbp)
jmp 0x2e79f
movsd -0x60(%rbp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x8(%rbp)
jmp 0x2e861
movb $0x1, -0x4a(%rbp)
movl $0x28, %edi
callq 0x8240
movq %rax, -0x70(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x87d0
movq -0x68(%rbp), %rdx
leaq 0xefb5(%rip), %rsi      # 0x3d791
leaq -0x48(%rbp), %rdi
callq 0x8610
jmp 0x2e7e7
movq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xd550
jmp 0x2e7f6
movq -0x70(%rbp), %rdi
movb $0x0, -0x4a(%rbp)
leaq 0x27563(%rip), %rsi     # 0x55d68
leaq -0x2124c(%rip), %rdx    # 0xd5c0
callq 0x8770
jmp 0x2e874
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2e836
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8878
leaq -0x49(%rbp), %rdi
callq 0x8490
testb $0x1, -0x4a(%rbp)
jne 0x2e847
jmp 0x2e850
movq -0x70(%rbp), %rdi
callq 0x8300
jmp 0x2e852
cmpl $0x0, -0x24(%rbp)
jge 0x2e86b
movq -0x20(%rbp), %rdi
callq 0x8590
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x87b0
nopw %cs:(%rax,%rax)
nop
// File: andrakis[P]alisp/repl.cpp
// Function: ALisp::REPL::_help(ALisp::REPL::State&)
void _help(State &state) {
			std::cout << "ALisp v " alisp_version_str << std::endl;
			std::cout << "Tab autocompletion available." << std::endl;
			std::cout << "Available REPL commands: " << std::endl;
			for (auto it = &replCommands[0]; it->valid(); ++it)
				std::cout << "\t" << it->command;
			std::cout << std::endl;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x26f65(%rip), %rdi     # 0x56fc8
leaq 0xd7de(%rip), %rsi      # 0x3d848
callq 0x83e0
movq %rax, %rdi
movq 0x26f17(%rip), %rsi     # 0x56f90
callq 0x8460
movq 0x26f43(%rip), %rdi     # 0x56fc8
leaq 0xd7da(%rip), %rsi      # 0x3d866
callq 0x83e0
movq %rax, %rdi
movq 0x26ef5(%rip), %rsi     # 0x56f90
callq 0x8460
movq 0x26f21(%rip), %rdi     # 0x56fc8
leaq 0xd7d6(%rip), %rsi      # 0x3d884
callq 0x83e0
movq %rax, %rdi
movq 0x26ed3(%rip), %rsi     # 0x56f90
callq 0x8460
leaq 0x27af7(%rip), %rax     # 0x57bc0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30ca0
testb $0x1, %al
jne 0x300dc
jmp 0x30109
movq 0x26ee5(%rip), %rdi     # 0x56fc8
leaq 0xd7b4(%rip), %rsi      # 0x3d89e
callq 0x83e0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x8390
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x10(%rbp)
jmp 0x300cd
movq 0x26eb8(%rip), %rdi     # 0x56fc8
movq 0x26e79(%rip), %rsi     # 0x56f90
callq 0x8460
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: andrakis[P]alisp/repl.cpp
// Function: ALisp::REPL::getCommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Command *getCommand(StringType cmd) {
			for (auto it = &replCommands[0]; it->valid(); ++it)
				if (it->command == cmd)
					return it;
			return nullptr;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x27a79(%rip), %rax     # 0x57bc0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30ca0
testb $0x1, %al
jne 0x3015a
jmp 0x30187
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x16d90
testb $0x1, %al
jne 0x3016d
jmp 0x30177
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3018f
jmp 0x30179
movq -0x18(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
jmp 0x3014b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: andrakis[P]alisp/repl.cpp
// Function: ALisp::REPL::check_linenoise()
void check_linenoise() {
			if (linenoise_initialized) return;
			
			linenoiseInstallWindowChangeHandler();
			linenoiseHistoryLoad(linenoise_history);
			linenoiseSetCompletionCallback(completion_hook);

			linenoise_initialized = true;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testb $0x1, 0x27765(%rip)     # 0x57cc0
je 0x3055f
jmp 0x30583
callq 0x23060
movq 0x272c5(%rip), %rdi     # 0x57830
callq 0x22e70
leaq -0x357(%rip), %rdi      # 0x30220
callq 0x22bd0
movb $0x1, 0x2773d(%rip)     # 0x57cc0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: andrakis[P]alisp/stdlib/conio.cpp
// Function: ALisp::Stdlib::print(std::vector<ALisp::Cell, std::allocator<ALisp::Cell>> const&)
Cell print(const ListType &args) {
			for (auto it = args.cbegin(); it != args.cend(); ++it) {
				if (it != args.cbegin())
					std::cout << " ";
				std::cout << it->str();
			}
			std::cout << std::endl;
			return Nil;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12f00
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12f30
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x12d80
testb $0x1, %al
jne 0x3488b
jmp 0x34917
movq -0x10(%rbp), %rdi
callq 0x12f00
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12d80
testb $0x1, %al
jne 0x348ab
jmp 0x348be
movq 0x22716(%rip), %rdi     # 0x56fc8
leaq 0x8340(%rip), %rsi      # 0x3cbf9
callq 0x83e0
leaq -0x18(%rbp), %rdi
callq 0x13690
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xd4b0
movq -0x70(%rbp), %rsi
movq 0x226e6(%rip), %rdi     # 0x56fc8
callq 0x8390
jmp 0x348e9
leaq -0x48(%rbp), %rdi
callq 0x8878
leaq -0x18(%rbp), %rdi
callq 0x12e10
jmp 0x34868
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8878
jmp 0x34944
movq 0x226aa(%rip), %rdi     # 0x56fc8
movq 0x2266b(%rip), %rsi     # 0x56f90
callq 0x8460
movq -0x68(%rbp), %rdi
leaq 0x23223(%rip), %rsi     # 0x57b58
callq 0xb900
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x87b0
nopl (%rax)
// File: andrakis[P]alisp/stdlib/debug.cpp
// Function: ALisp::Stdlib::debug_eval(std::vector<ALisp::Cell, std::allocator<ALisp::Cell>> const&, std::shared_ptr<ALisp::Environment>)
Cell debug_eval(const ListType &args, EnvironmentType env) {
			RUNTIME_CHECK(args, runtime_check::has_atleast_one_argument);
			Cell env_used;

			if (runtime_check::has_two_arguments(args))
				env_used = args[1];
			else
				env_used = EnvironmentCell(env);
			return Eval::Simple::eval(args[0], env_used);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x80(%rbp)
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x35200
testb $0x1, %al
jne 0x350ff
movb $0x1, -0x45(%rbp)
movl $0x28, %edi
callq 0x8240
movq %rax, -0x88(%rbp)
leaq 0x22cd5(%rip), %rsi     # 0x57d58
leaq -0x38(%rbp), %rdi
callq 0x8200
jmp 0x3508e
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd550
jmp 0x350a0
movq -0x88(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x20cb6(%rip), %rsi     # 0x55d68
leaq -0x27af9(%rip), %rdx    # 0xd5c0
callq 0x8770
jmp 0x351f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x350e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8878
testb $0x1, -0x45(%rbp)
jne 0x350ee
jmp 0x350fa
movq -0x88(%rbp), %rdi
callq 0x8300
jmp 0x351f0
leaq -0x50(%rbp), %rdi
callq 0xce00
movq -0x10(%rbp), %rdi
callq 0x35220
movb %al, -0x89(%rbp)
jmp 0x35119
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x35125
jmp 0x35154
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x15190
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
callq 0xd650
jmp 0x35141
jmp 0x351b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x351e7
movq -0x80(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xf830
movq -0x98(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xb880
jmp 0x3517a
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x13810
leaq -0x58(%rbp), %rdi
callq 0xc060
leaq -0x68(%rbp), %rdi
callq 0xb8e0
jmp 0x351b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xb8e0
jmp 0x351e7
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15190
movq -0x78(%rbp), %rdi
movq %rax, %rsi
leaq -0x50(%rbp), %rdx
callq 0x27080
jmp 0x351d1
leaq -0x50(%rbp), %rdi
callq 0xb9d0
movq -0x70(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0xb9d0
movq -0x40(%rbp), %rdi
callq 0x87b0
nopl (%rax)
// File: andrakis[P]alisp/stdlib/operators.cpp
// Function: ALisp::Stdlib::plus(std::vector<ALisp::Cell, std::allocator<ALisp::Cell>> const&)
Cell plus(const ListType &args) {
			RUNTIME_CHECK(args, runtime_check::has_atleast_one_argument);
			RUNTIME_EARLY_RETURN(args, runtime_check::has_one_argument, args[0]);
			auto it = args.cbegin();
			Cell value(*it++);
			for (; it != args.cend(); ++it)
				value += *it;
			return value;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x37000
testb $0x1, %al
jne 0x36f0b
movb $0x1, -0x3d(%rbp)
movl $0x28, %edi
callq 0x8240
movq %rax, -0x78(%rbp)
leaq 0x21048(%rip), %rsi     # 0x57ee0
leaq -0x30(%rbp), %rdi
callq 0x8200
jmp 0x36ea3
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xd550
jmp 0x36eb2
movq -0x78(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq 0x1eea7(%rip), %rsi     # 0x55d68
leaq -0x29908(%rip), %rdx    # 0xd5c0
callq 0x8770
jmp 0x36ff3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x36ef5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8878
testb $0x1, -0x3d(%rbp)
jne 0x36efd
jmp 0x36f06
movq -0x78(%rbp), %rdi
callq 0x8300
jmp 0x36fea
movq -0x10(%rbp), %rdi
callq 0x37020
testb $0x1, %al
jne 0x36f1a
jmp 0x36f38
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15190
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0xb900
jmp 0x36fdd
movq -0x10(%rbp), %rdi
callq 0x12f00
movq %rax, -0x48(%rbp)
movb $0x0, -0x49(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x37ea0
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x12df0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0xb900
movq -0x10(%rbp), %rdi
callq 0x12f30
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x12d80
testb $0x1, %al
jne 0x36f8d
jmp 0x36fc8
leaq -0x48(%rbp), %rdi
callq 0x12df0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x37ee0
jmp 0x36fa4
jmp 0x36fa6
leaq -0x48(%rbp), %rdi
callq 0x12e10
jmp 0x36f6d
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0xb9d0
jmp 0x36fea
movb $0x1, -0x49(%rbp)
testb $0x1, -0x49(%rbp)
jne 0x36fdb
movq -0x70(%rbp), %rdi
callq 0xb9d0
jmp 0x36fdd
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x87b0
nopw %cs:(%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/simulate.cpp
// Function: get_arg_index(char const*)
int get_arg_index(const char* name) {
    auto it = arg_name_to_index.find(name);
    if(it == arg_name_to_index.end()) {
        fprintf(stderr, "argument %s not found\n", name);
        return -1;
    }
    else {
        return it->second;
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x22c0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x2200
jmp 0x213a8
leaq 0x179f1(%rip), %rdi     # 0x38da0
leaq 0x40(%rsp), %rsi
callq 0x22f70
movq %rax, 0x8(%rsp)
jmp 0x213c0
movq 0x8(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x20e0
leaq 0x3f(%rsp), %rdi
callq 0x21d0
leaq 0x179bb(%rip), %rdi     # 0x38da0
callq 0x22fc0
movq %rax, 0x20(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x22fa0
testb $0x1, %al
jne 0x21404
jmp 0x2145f
movq 0x16bbd(%rip), %rax     # 0x37fc8
movq (%rax), %rdi
movq 0x68(%rsp), %rdx
leaq 0x86a8(%rip), %rsi      # 0x29ac2
movb $0x0, %al
callq 0x2220
movl $0xffffffff, 0x74(%rsp) # imm = 0xFFFFFFFF
jmp 0x21470
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x21453
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x20e0
leaq 0x3f(%rsp), %rdi
callq 0x21d0
jmp 0x21479
leaq 0x60(%rsp), %rdi
callq 0x22ff0
movl 0x20(%rax), %eax
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/simulate.cpp
// Function: print_usage(_IO_FILE*, char const*)
static void print_usage(FILE* fp, const char* argv0) {
    fprintf(fp, "usage: %s", argv0);
    for(int i=0; i<n_arg_list; ++i) {
        const ArgSpec& arg_spec = arg_list[i];
        fprintf(fp, " %s(=%s)", arg_spec.name.c_str(), arg_spec.defval_s.c_str());
    }
    fprintf(fp, "\n");
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rdx
leaq 0x730f(%rip), %rsi      # 0x29c1e
movb $0x0, %al
callq 0x2220
movl $0x0, 0x24(%rsp)
cmpl $0x13, 0x24(%rsp)
jge 0x2298f
movslq 0x24(%rsp), %rcx
leaq 0x1588f(%rip), %rax     # 0x381c0
imulq $0xa0, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2090
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
callq 0x2090
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0x72ad(%rip), %rsi      # 0x29c28
movb $0x0, %al
callq 0x2220
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x2291e
movq 0x30(%rsp), %rdi
leaq 0x71a2(%rip), %rsi      # 0x29b3d
movb $0x0, %al
callq 0x2220
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/util.hpp
// Function: fill_ivec_from_str(char*, std::vector<int, std::allocator<int>>&, char const*)
static inline void fill_ivec_from_str(char* s, ivec& c, const char* sep) {
    char* tok = std::strtok(s, sep);
    while(tok) {
        c.push_back(std::atoi(tok));
        tok = std::strtok(nullptr, sep);
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2270
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x22adb
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2260
movq 0x8(%rsp), %rdi
movl %eax, 0x14(%rsp)
leaq 0x14(%rsp), %rsi
callq 0x4c50
movq 0x20(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x2270
movq %rax, 0x18(%rsp)
jmp 0x22a97
addq $0x38, %rsp
retq
// File: sharmaeklavya2[P]ddos-on-anycast/src/simulate.cpp
// Function: int coalesce<int>(int, int, bool)
static T coalesce(T value, T replacement, bool zero_is_null) {
    if(zero_is_null) {
        return value <= 0 ? replacement : value;
    }
    else {
        return value < 0 ? replacement : value;
    }
}

// Assembly:
movb %dl, %al
movl %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
andb $0x1, %al
movb %al, -0xd(%rsp)
testb $0x1, -0xd(%rsp)
je 0x22b4a
cmpl $0x0, -0x8(%rsp)
jg 0x22b38
movl -0xc(%rsp), %eax
movl %eax, -0x14(%rsp)
jmp 0x22b40
movl -0x8(%rsp), %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x22b6b
cmpl $0x0, -0x8(%rsp)
jge 0x22b5b
movl -0xc(%rsp), %eax
movl %eax, -0x18(%rsp)
jmp 0x22b63
movl -0x8(%rsp), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
// File: sharmaeklavya2[P]ddos-on-anycast/src/simulate.cpp
// Function: ArgSpec::ArgSpec(char const*, char, char const*, bool, char const*)
ArgSpec(const char* _name, char _type, const char* _defval_s, bool _zero_is_null, const char* _description):
        name(_name), type(_type), defval_s(_defval_s), val_s(_defval_s), zero_is_null(_zero_is_null), description(_description) {
        if(type == 'i') {
            defval_i = val_i = atoi(_defval_s);
        }
        else if(type == 'f') {
            defval_f = val_f = atof(_defval_s);
        }
    }

// Assembly:
subq $0xb8, %rsp
movb %r8b, %al
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movb %dl, 0xa7(%rsp)
movq %rcx, 0x98(%rsp)
andb $0x1, %al
movb %al, 0x97(%rsp)
movq %r9, 0x88(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x58(%rsp)
movq %rax, 0x50(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x87(%rsp), %rdi
movq %rdi, 0x68(%rsp)
callq 0x22c0
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x2200
jmp 0x22c81
leaq 0x87(%rsp), %rdi
callq 0x21d0
movq 0x50(%rsp), %rax
movb 0xa7(%rsp), %cl
movb %cl, 0x20(%rax)
addq $0x28, %rax
movq %rax, 0x38(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x73(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x22c0
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x2200
jmp 0x22cd8
leaq 0x73(%rsp), %rdi
callq 0x21d0
movq 0x50(%rsp), %rax
addq $0x58, %rax
movq %rax, 0x20(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x72(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x22c0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x2200
jmp 0x22d22
leaq 0x72(%rsp), %rdi
callq 0x21d0
movq 0x50(%rsp), %rax
movb 0x97(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x78(%rax)
subq $-0x80, %rax
movq %rax, 0x8(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x71(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x22c0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x2200
jmp 0x22d79
leaq 0x71(%rsp), %rdi
callq 0x21d0
movq 0x50(%rsp), %rax
movsbl 0x20(%rax), %eax
cmpl $0x69, %eax
jne 0x22e2c
movq 0x98(%rsp), %rdi
callq 0x2260
movl %eax, %ecx
movq 0x50(%rsp), %rax
movl %ecx, 0x50(%rax)
movl %ecx, 0x48(%rax)
jmp 0x22e58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x87(%rsp), %rdi
callq 0x21d0
jmp 0x22e74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x73(%rsp), %rdi
callq 0x21d0
jmp 0x22e6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x72(%rsp), %rdi
callq 0x21d0
jmp 0x22e60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x71(%rsp), %rdi
callq 0x21d0
movq 0x20(%rsp), %rdi
callq 0x20e0
jmp 0x22e60
movq 0x50(%rsp), %rax
movsbl 0x20(%rax), %eax
cmpl $0x66, %eax
jne 0x22e56
movq 0x98(%rsp), %rdi
callq 0x21e0
movq 0x50(%rsp), %rax
movsd %xmm0, 0x50(%rax)
movsd %xmm0, 0x48(%rax)
jmp 0x22e58
addq $0xb8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x20e0
movq 0x58(%rsp), %rdi
callq 0x20e0
movq 0x78(%rsp), %rdi
callq 0x22b0
nop