LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: linenoiseHistoryLoad
int linenoiseHistoryLoad(const char* filename) {
  FILE* fp = fopen(filename, "rt");
  if (fp == NULL) {
    return -1;
  }

  char buf[LINENOISE_MAX_LINE];
  while (fgets(buf, LINENOISE_MAX_LINE, fp) != NULL) {
    char* p = strchr(buf, '\r');
    if (!p) {
      p = strchr(buf, '\n');
    }
    if (p) {
      *p = '\0';
    }
    if (p != buf) {
      linenoiseHistoryAdd(buf);
    }
  }
  fclose(fp);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
leaq 0xd737(%rip), %rsi      # 0x212f5
callq 0x73f0
testq %rax, %rax
je 0x13c25
movq %rax, %rbx
movq %rsp, %r14
movq %r14, %rdi
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdx
callq 0x7560
testq %rax, %rax
je 0x13c19
movq %r14, %rdi
movl $0xd, %esi
callq 0x7150
testq %rax, %rax
jne 0x13c02
movq %r14, %rdi
movl $0xa, %esi
callq 0x7150
testq %rax, %rax
je 0x13c0a
movb $0x0, (%rax)
cmpq %r14, %rax
je 0x13bce
movq %r14, %rdi
callq 0x13405
jmp 0x13bce
movq %rbx, %rdi
callq 0x72f0
xorl %eax, %eax
jmp 0x13c2a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: linenoisePrintKeyCodes
void linenoisePrintKeyCodes(void) {
  char quit[4];

  printf(
      "Linenoise key codes debugging mode.\n"
      "Press keys to see scan codes. Type 'quit' at any time to exit.\n");
  if (enableRawMode() == -1) return;
  memset(quit, ' ', 4);
  while (1) {
    char c;
    int nread;

#if _WIN32
    nread = _read(STDIN_FILENO, &c, 1);
#else
    nread = read(STDIN_FILENO, &c, 1);
#endif
    if (nread <= 0) continue;
    memmove(quit, quit + 1, sizeof(quit) - 1); /* shift string to left. */
    quit[sizeof(quit) - 1] = c; /* Insert current char on the right. */
    if (memcmp(quit, "quit", sizeof(quit)) == 0) break;

    printf("'%c' %02x (%d) (type quit to exit)\n", isprint(c) ? c : '?', (int)c,
           (int)c);
    printf("\r"); /* Go left edge manually, we are in raw mode. */
    fflush(stdout);
  }
  disableRawMode();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xe0fe(%rip), %rdi      # 0x21d46
callq 0x7530
callq 0x11f82
cmpl $-0x1, %eax
je 0x13d13
leaq 0x5(%rsp), %r15
movl $0x20202020, -0x1(%r15) # imm = 0x20202020
leaq 0x3(%rsp), %rbx
movl $0x3f, %r12d
leaq 0xdf8a(%rip), %r14      # 0x21c04
movq 0x1b2ff(%rip), %r13     # 0x2ef80
movl $0x1, %edx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x7500
testl %eax, %eax
jle 0x13c81
movzwl (%r15), %eax
movb 0x2(%r15), %cl
movb %cl, 0x6(%rsp)
movw %ax, 0x4(%rsp)
movsbl 0x3(%rsp), %ebp
movb %bpl, 0x7(%rsp)
cmpl $0x74697571, 0x4(%rsp)  # imm = 0x74697571
je 0x13ceb
movl %ebp, %edi
callq 0x7630
testl %eax, %eax
movl %ebp, %esi
cmovel %r12d, %esi
movq %r14, %rdi
movl %ebp, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x7070
movl $0xd, %edi
callq 0x74c0
movq (%r13), %rdi
callq 0x73e0
jmp 0x13c81
cmpb $0x1, 0x1bcee(%rip)     # 0x2f9e0
jne 0x13d13
leaq 0x1bce9(%rip), %rdx     # 0x2f9e4
xorl %edi, %edi
movl $0x1, %esi
callq 0x7460
cmpl $-0x1, %eax
je 0x13d13
movb $0x0, 0x1bccd(%rip)     # 0x2f9e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: linenoiseInstallWindowChangeHandler
int linenoiseInstallWindowChangeHandler(void) {
#ifndef _WIN32
  struct sigaction sa;
  sigemptyset(&sa.sa_mask);
  sa.sa_flags = 0;
  sa.sa_handler = &WindowSizeChanged;

  if (sigaction(SIGWINCH, &sa, nullptr) == -1) {
    return errno;
  }
#endif
  return 0;
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x7440
movl $0x0, 0x80(%rbx)
leaq 0x2e(%rip), %rax        # 0x13d76
movq %rax, -0x8(%rbx)
xorl %ebx, %ebx
leaq 0x8(%rsp), %rsi
movl $0x1c, %edi
xorl %edx, %edx
callq 0x7450
cmpl $-0x1, %eax
jne 0x13d6b
callq 0x7060
movl (%rax), %ebx
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: copyString8to32(char32_t*, unsigned long, unsigned long&, char const*)
static ConversionResult copyString8to32(char32_t* dst, size_t dstSize,
                                        size_t& dstCount, const char* src) {
  const UTF8* sourceStart = reinterpret_cast<const UTF8*>(src);
  const UTF8* sourceEnd = sourceStart + strlen(src);
  UTF32* targetStart = reinterpret_cast<UTF32*>(dst);
  UTF32* targetEnd = targetStart + dstSize;

  ConversionResult res = ConvertUTF8toUTF32(
      &sourceStart, sourceEnd, &targetStart, targetEnd, lenientConversion);

  if (res == conversionOK) {
    dstCount = targetStart - reinterpret_cast<UTF32*>(dst);

    if (dstCount < dstSize) {
      *targetStart = 0;
    }
  }

  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %r13
movq %rcx, (%r13)
movq %rcx, %rdi
callq 0x7180
addq %rax, %r12
movq %rsp, %rdx
movq %r15, (%rdx)
leaq (%r15,%rbx,4), %rcx
movq %r13, %rdi
movq %r12, %rsi
movl $0x1, %r8d
callq 0xff40
testl %eax, %eax
jne 0x13ded
movq (%rsp), %rcx
movq %rcx, %rdx
subq %r15, %rdx
sarq $0x2, %rdx
movq %rdx, (%r14)
cmpq %rbx, %rdx
jae 0x13ded
movl $0x0, (%rcx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: copyString32to8(char*, unsigned long, unsigned long*, char32_t const*, unsigned long)
static void copyString32to8(char* dst, size_t dstSize, size_t* dstCount,
                            const char32_t* src, size_t srcSize) {
  const UTF32* sourceStart = reinterpret_cast<const UTF32*>(src);
  const UTF32* sourceEnd = sourceStart + srcSize;
  UTF8* targetStart = reinterpret_cast<UTF8*>(dst);
  UTF8* targetEnd = targetStart + dstSize;

  ConversionResult res = ConvertUTF32toUTF8(
      &sourceStart, sourceEnd, &targetStart, targetEnd, lenientConversion);

  if (res == conversionOK) {
    *dstCount = targetStart - reinterpret_cast<UTF8*>(dst);

    if (*dstCount < dstSize) {
      *targetStart = 0;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
movq %rcx, (%rdi)
leaq (%rcx,%r8,4), %rsi
movq %rsp, %rdx
movq %r15, (%rdx)
leaq (%r15,%rbx), %rcx
movl $0x1, %r8d
callq 0xfe03
testl %eax, %eax
jne 0x13e47
movq (%rsp), %rax
movq %rax, %rcx
subq %r15, %rcx
movq %rcx, (%r14)
cmpq %rbx, %rcx
jae 0x13e47
movb $0x0, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x7(%rsp), %rbx
leaq 0x1bb61(%rip), %r14     # 0x2f9cc
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movl $0x1, %edx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x7500
movq %rax, %r13
cmpq $-0x1, %rax
jne 0x13e97
callq 0x7060
cmpl $0x4, (%rax)
je 0x13e75
testq %r13, %r13
jle 0x13eb6
movsbl 0x7(%rsp), %ecx
testl %ecx, %ecx
js 0x13ebc
movq $0x0, 0x1bb28(%rip) # 0x2f9d8
xorl %eax, %eax
movl %ecx, %ebp
jmp 0x13f21
xorl %eax, %eax
xorl %ebp, %ebp
jmp 0x13f21
movq 0x1bb15(%rip), %rax     # 0x2f9d8
cmpq $0x3, %rax
ja 0x13f14
leaq 0x1(%rax), %rdx
movq %rdx, 0x1bb04(%rip)     # 0x2f9d8
movb %cl, (%rax,%r14)
movb $0x0, 0x1(%rax,%r14)
movl $0x2, %esi
movq %r15, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x13d85
testl %eax, %eax
setne %cl
cmpq $0x0, 0x8(%rsp)
sete %al
orb %cl, %al
jne 0x13f21
movq $0x0, 0x1baca(%rip) # 0x2f9d8
movl 0x10(%rsp), %ebp
jmp 0x13f21
movq $0x0, 0x1bab9(%rip) # 0x2f9d8
movb $0x1, %al
testb %al, %al
jne 0x13e75
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
movl (%rsi), %ecx
testl %ecx, %ecx
setne %bpl
je 0x13f84
movq 0x8(%r14), %rdx
movzbl (%rdx), %eax
cmpl %ebx, %eax
jne 0x13f5c
xorl %eax, %eax
jmp 0x13f77
leal -0x1(%rcx), %esi
xorl %eax, %eax
cmpl %eax, %esi
je 0x13f82
movzbl 0x1(%rdx,%rax), %edi
incq %rax
cmpl %ebx, %edi
jne 0x13f61
cmpl %ecx, %eax
setb %bpl
movq 0x10(%r14), %rcx
movl %ebx, %edi
callq *(%rcx,%rax,8)
jmp 0x13f84
xorl %ebp, %ebp
testb %bpl, %bpl
je 0x13f8e
popq %rbx
popq %r14
popq %rbp
retq
movq 0x10(%r14), %rax
movl (%r14), %ecx
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmpq *(%rax,%rcx,8)
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl $0x40000000, 0x1b9b9(%rip) # imm = 0x40000000
cmpl $0x1b, %edi
jne 0x14031
pushq %rax
callq 0x13e51
testl %eax, %eax
leaq 0x8(%rsp), %rsp
je 0x1403d
leaq 0x1b37e(%rip), %rsi     # 0x2f3a8
movl %eax, %edi
jmp 0x13f3a
leaq 0x1b340(%rip), %rsi     # 0x2f378
jmp 0x13f3a
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
callq 0x13e51
testl %eax, %eax
je 0x14220
orb $0x40, 0x1b7ba(%rip)    # 0x2f9cb
leaq 0x1b2c0(%rip), %rsi     # 0x2f4d8
movl %eax, %edi
popq %rax
jmp 0x13f3a
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
callq 0x13e51
testl %eax, %eax
je 0x14244
orb $0x20, 0x1b796(%rip)    # 0x2f9cb
leaq 0x1b29c(%rip), %rsi     # 0x2f4d8
movl %eax, %edi
popq %rax
jmp 0x13f3a
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, %rdi
callq 0x7180
leaq 0x1(%rax), %r15
movq %r15, %rcx
shrq $0x3e, %rcx
leaq 0x4(,%rax,4), %rax
xorl %r12d, %r12d
negq %rcx
sbbq %r12, %r12
orq %rax, %r12
movq %r12, %rdi
callq 0x7030
movq %rax, %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x7200
movq %r13, 0x8(%r14)
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x13d85
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x15006
movl (%r14), %eax
movl %eax, 0x58(%rbx)
leaq 0x40(%rbx), %rdi
movq %r14, %rsi
callq 0x147da
movq %rbx, %rdi
callq 0x14690
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1466e
callq 0x7480
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14688
callq 0x7480
movq %rbx, %rdi
callq 0x7620
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x5c(%rdi)
leaq 0x1b234(%rip), %rax     # 0x2f8e0
leaq 0x1b23d(%rip), %rcx     # 0x2f8f0
cmovgq %rax, %rcx
movq (%rcx), %rbp
movslq 0x58(%rdi), %rax
movq %rax, 0x18(%rsp)
movl %eax, %eax
leaq 0x1b21c(%rip), %rcx     # 0x2f8e8
leaq 0x1b225(%rip), %r12     # 0x2f8f8
cmovgq %rcx, %r12
movq 0x1b222(%rip), %rcx     # 0x2f900
movq %rcx, 0x20(%rsp)
addq %rcx, %rax
addq %rbp, %rax
movl %eax, 0x18(%rdi)
movl %eax, 0x1c(%rdi)
movq %rax, %rcx
shlq $0x20, %rcx
movabsq $0x100000000, %r15      # imm = 0x100000000
addq %rcx, %r15
sarq $0x1e, %r15
cmpl $-0x1, %eax
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $-0x1, %r13
cmovlq %r13, %r15
movq %r15, %rdi
callq 0x7030
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x7200
movq %r14, 0x8(%rsp)
movq (%r12), %rsi
leaq (,%rbp,4), %rdx
movq %r14, %rdi
callq 0x72a0
leaq (%r14,%rbp,4), %r15
movq 0x48(%rbx), %rsi
movq 0x18(%rsp), %r12
leaq (,%r12,4), %rdx
movq %r15, %rdi
callq 0x72a0
leaq (%r15,%r12,4), %rdi
movq 0x1b193(%rip), %rsi     # 0x2f908
movq 0x20(%rsp), %rax
leaq 0x4(,%rax,4), %rdx
callq 0x72a0
cmpl $0x0, 0x4(%r14,%r13,4)
leaq 0x1(%r13), %r13
jne 0x14787
movq %rsp, %rsi
movq %r13, (%rsi)
movq %rbx, %rdi
callq 0x147da
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x147b0
callq 0x7480
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x147d1
callq 0x7480
movq %rbx, %rdi
callq 0x7620
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1484a
movq %rsi, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x147fe
callq 0x7480
movq (%r14), %rbp
movq %rbp, %rax
shrq $0x3e, %rax
leaq (,%rbp,4), %r15
xorl %r12d, %r12d
negq %rax
sbbq %r12, %r12
orq %r15, %r12
movq %r12, %rdi
callq 0x7030
movq %rax, %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x7200
movq %r13, 0x8(%rbx)
movq %rbp, (%rbx)
movq 0x8(%r14), %rsi
movq %r13, %rdi
movq %r15, %rdx
callq 0x72a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq %rsp, %r14
movq $0x0, (%r14)
movq (%rdi), %rdi
movslq 0x10(%rbx), %rsi
incq %rsi
movq %r14, %rdx
callq 0x13d85
movq (%r14), %r14
testl %r14d, %r14d
jle 0x14d55
movq (%rbx), %r15
movq 0x8(%rbx), %r12
movl %r14d, %r13d
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
movl (%r15,%rbp,4), %edi
callq 0x15608
movb %al, (%r12,%rbp)
incq %rbp
cmpq %rbp, %r13
jne 0x14d40
movl %r14d, 0x14(%rbx)
movl %r14d, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, %r15
incq %rax
cmpl $0x0, (%rbx,%r15,4)
jne 0x1501d
movq %r15, (%r14)
leaq 0x1(%r15), %rax
shrq $0x3e, %rax
leaq 0x4(,%r15,4), %rcx
xorl %r12d, %r12d
negq %rax
sbbq %r12, %r12
orq %rcx, %r12
movq %r12, %rdi
callq 0x7030
movq %rax, %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x7200
movq %r13, 0x8(%r14)
shlq $0x2, %r15
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x72a0
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %eax, %eax
cmpl %edi, (%rsi)
ja 0x15756
movl %edx, %ecx
cmpl %edi, 0x4(%rsi,%rcx,8)
setb %cl
testl %edx, %edx
sets %r8b
orb %cl, %r8b
jne 0x15756
xorl %eax, %eax
leal (%rax,%rdx), %r8d
movl %r8d, %ecx
shrl $0x1f, %ecx
addl %r8d, %ecx
sarl %ecx
movslq %ecx, %r8
cmpl %edi, 0x4(%rsi,%r8,8)
jae 0x15746
incl %ecx
movl %ecx, %eax
jmp 0x15750
cmpl %edi, (%rsi,%r8,8)
jbe 0x15757
decl %ecx
movl %ecx, %edx
cmpl %eax, %edx
jge 0x15727
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movl (%rdi), %edi
testl %edi, %edi
je 0x15794
movq %rsi, %r14
xorl %r12d, %r12d
xorl %ebx, %ebx
cmpq %r12, %r14
je 0x1579d
callq 0x15608
testl %eax, %eax
js 0x15798
addl %eax, %ebx
movl 0x4(%r15,%r12,4), %edi
incq %r12
testl %edi, %edi
jne 0x15776
jmp 0x1579d
xorl %ebx, %ebx
jmp 0x1579d
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movl (%rdi), %edi
testl %edi, %edi
je 0x15809
movq %rsi, %r14
xorl %r12d, %r12d
xorl %ebx, %ebx
cmpq %r12, %r14
je 0x15812
callq 0x157ab
testl %eax, %eax
js 0x1580d
addl %eax, %ebx
movl 0x4(%r15,%r12,4), %edi
incq %r12
testl %edi, %edi
jne 0x157eb
jmp 0x15812
xorl %ebx, %ebx
jmp 0x15812
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x16ec2
testq %rax, %rax
je 0x16b25
movq 0x10(%rax), %rsi
testq %rsi, %rsi
je 0x16b3b
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *(%rax)
movq 0x8(%rsp), %rax
xorl %ecx, %ecx
movq %rcx, 0x8(%rsp)
movq %rax, (%rbx)
movq %rcx, 0x8(%rsp)
jmp 0x16b42
movq 0x38(%r15), %rsi
testq %rsi, %rsi
je 0x16b4f
movq %rbx, %rdi
movq %r14, %rdx
callq 0x16ada
jmp 0x16b42
movq $0x0, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x28, %edi
callq 0x71b0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x16f28
leaq 0x178e2(%rip), %rsi     # 0x2e450
leaq -0xbd07(%rip), %rdx     # 0xae6e
movq %r15, %rdi
callq 0x75f0
movq %rdx, %r14
movq %rax, %rbx
movq %r15, %rdi
callq 0x7260
jmp 0x16b93
movq %rdx, %r14
movq %rax, %rbx
movq %rbx, %rdi
testl %r14d, %r14d
jns 0x16ba0
callq 0x7470
callq 0x7620
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1703a
testb %al, %al
je 0x16be8
movq (%r15), %rsi
testq %rsi, %rsi
je 0x16c1c
movq (%rsi), %rax
leaq 0x18(%rsp), %rdi
callq *(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x18(%rsp)
movq %rax, 0x10(%rsp)
jmp 0x16c25
movq 0x38(%r14), %r14
testq %r14, %r14
je 0x16c99
movq (%r15), %rsi
testq %rsi, %rsi
je 0x16c5d
movq (%rsi), %rax
leaq 0x18(%rsp), %rdi
callq *(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x18(%rsp)
movq %rax, 0x8(%rsp)
jmp 0x16c66
movq $0x0, 0x10(%rsp)
leaq 0x18(%rsp), %rsi
movq %rbx, (%rsi)
movq %r14, %rdi
callq 0xaee2
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0xae9e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x16c52
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x10(%rsp)
jmp 0x16c8f
movq $0x0, 0x8(%rsp)
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x16ba6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x16c86
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x8(%rsp)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x28, %edi
callq 0x71b0
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16f28
leaq 0x17798(%rip), %rsi     # 0x2e450
leaq -0xbe51(%rip), %rdx     # 0xae6e
movq %r15, %rdi
callq 0x75f0
movq %rdx, %r14
movq %rax, %rbx
movq %r15, %rdi
callq 0x7260
jmp 0x16d1f
movq %rdx, %r14
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x16ced
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x16d1f
movq %rdx, %r14
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x16d0e
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x10(%rsp)
jmp 0x16d1f
movq %rdx, %r14
movq %rax, %rbx
movq %rbx, %rdi
testl %r14d, %r14d
jns 0x16d2c
callq 0x7470
callq 0x7620
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq (%rsi), %r12
cmpq 0x8(%rsi), %r12
je 0x184d3
movq %rdx, %rbx
movq (%rdx), %r13
cmpq 0x8(%rdx), %r13
je 0x184d3
movq %rsi, %r14
addq $0x8, %r13
leaq 0x8(%rsp), %r15
movq %r12, %rdi
callq 0xadcc
movq %rax, %rbp
movq -0x8(%r13), %rsi
testq %rsi, %rsi
je 0x1847c
movq (%rsi), %rax
movq %r15, %rdi
callq *(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rsp)
movq %rax, (%rsp)
jmp 0x18484
movq $0x0, (%rsp)
movq %rbp, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0xaee2
movq %rax, %rdi
movq %rsp, %rsi
callq 0xae9e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x184b0
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, (%rsp)
addq $0x8, %r12
cmpq 0x8(%r14), %r12
je 0x184d3
leaq 0x8(%r13), %rax
cmpq 0x8(%rbx), %r13
movq %rax, %r13
jne 0x1844c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x184f4
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, (%rsp)
movq %rbx, %rdi
callq 0x7620
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movsbl (%rax), %edx
cmpl $0x22, %edx
jne 0x18862
movq 0x8(%r14), %rcx
cmpb $0x22, -0x1(%rax,%rcx)
jne 0x18862
addq $-0x2, %rcx
leaq 0x30(%rsp), %rdi
movl $0x1, %edx
movq %r14, %rsi
callq 0x7350
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xa9fa
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rsp)
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18917
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0x18917
leal -0x30(%rdx), %ecx
cmpl $0xa, %ecx
jae 0x188a7
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xe05c
cmpb $0x1, 0x10(%rsp)
jne 0x188ba
movq 0x8(%rsp), %r14
movl $0x18, %edi
callq 0x7300
movl $0x2, 0x8(%rax)
leaq 0x15ea5(%rip), %rcx     # 0x2e740
movq %rcx, (%rax)
movq %r14, 0x10(%rax)
movq %rax, (%rbx)
jmp 0x18917
cmpb $0x2d, %dl
jne 0x1890c
movsbl 0x1(%rax), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
jbe 0x1886a
jmp 0x1890c
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0xe165
movb 0x28(%rsp), %bpl
cmpb $0x1, %bpl
jne 0x1890c
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x18, %edi
callq 0x7300
movl $0x3, 0x8(%rax)
leaq 0x15f7a(%rip), %rcx     # 0x2e870
movq %rcx, (%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movq %rax, (%rbx)
testb %bpl, %bpl
jne 0x18917
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xe973
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x18950
jmp 0x18950
jmp 0x18950
movq %rdx, %r14
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18956
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x7320
jmp 0x18956
jmp 0x18950
jmp 0x18950
movq %rdx, %r14
movq %rax, %rbx
movq %rbx, %rdi
testl %r14d, %r14d
jns 0x18963
callq 0x7470
callq 0x7620
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpb $0x0, 0x15ea0(%rip)     # 0x2fb90
jne 0x19d1b
pushq %rax
callq 0x13d22
movq 0x15a01(%rip), %rdi     # 0x2f700
callq 0x13bad
leaq -0x329(%rip), %rdi      # 0x199e2
callq 0x13a18
movb $0x1, 0x15e79(%rip)     # 0x2fb90
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, (%rsp)
movq (%rsi), %r15
cmpq 0x8(%rsi), %r15
je 0x1c19d
movq %rsi, %r14
leaq 0x18(%rsp), %rbx
leaq 0x8(%rsp), %r12
movq 0x12e85(%rip), %r13     # 0x2efc8
leaq 0x5b35(%rip), %rbp      # 0x21c7f
cmpq (%r14), %r15
je 0x1c15f
movl $0x1, %edx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x73c0
movq %r12, %rdi
movq %r15, %rsi
callq 0xadea
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r13, %rdi
callq 0x73c0
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x1c193
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7320
addq $0x8, %r15
cmpq 0x8(%r14), %r15
jne 0x1c14a
movq 0x12e24(%rip), %r14     # 0x2efc8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x72d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7230
leaq 0x13856(%rip), %rax     # 0x2fa28
movq (%rax), %rsi
testq %rsi, %rsi
je 0x1c1fb
movq (%rsi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq *(%rax)
movq (%r14), %rdx
xorl %ecx, %ecx
movq %rcx, (%r14)
movq (%rsp), %rax
movq %rdx, (%rax)
movq %rcx, (%r14)
jmp 0x1c206
movq (%rsp), %rax
movq $0x0, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x1c22f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7320
movq %r14, %rdi
callq 0x7620
nop
// File: /workspace/github_cpp_makefile_star2_O1/andrakis[P]alisp/stdlib/../contrib/TextUtils.h
// Function: void TextUtils::Split<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Split(char delimiter, Output &output, Input const& input) {
		using namespace std;
		for (auto cur = begin(input), beg = cur; ; ++cur) {
			if (cur == end(input) || *cur == delimiter || !*cur) {
				output.insert(output.end(), Value(beg, cur));
				if (cur == end(input) || !*cur)
					break;
				else
					beg = next(cur);
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, 0x4(%rsp)
movq (%rdx), %r15
leaq 0x18(%rsp), %rbp
leaq 0x8(%rsp), %r12
movq %r15, %rsi
movq (%rbx), %rax
addq 0x8(%rbx), %rax
cmpq %rax, %r15
je 0x1f18a
movb (%r15), %al
cmpb 0x4(%rsp), %al
setne %cl
testb %al, %al
setne %al
testb %al, %cl
jne 0x1f1d9
movq 0x8(%r14), %r13
movq %rbp, 0x8(%rsp)
movq %r12, %rdi
movq %r15, %rdx
callq 0x1f59e
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1f26c
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1f1c3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7320
movq (%rbx), %rax
addq 0x8(%rbx), %rax
cmpq %rax, %r15
je 0x1f1de
cmpb $0x0, (%r15)
je 0x1f1de
leaq 0x1(%r15), %rsi
incq %r15
jmp 0x1f16b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1f207
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7320
movq %rbx, %rdi
callq 0x7620
nop
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ddos-on-anycast/src/simulate.cpp
// Function: print_stats(char const*, int, std::vector<double, std::allocator<double>>&, bool)
void print_stats(const char* name, int n_victims, vector<double>& xs, bool csvout) {
    std::sort(xs.begin(), xs.end());
    double xsum = 0;
    double xsum2 = 0;
    for(double x: xs) {
        xsum += x;
        xsum2 += x * x;
    }
    int n = xs.size();
    double mean = xsum / n;
    double variance = (xsum2 - xsum*xsum/n)/(n-1);
    double stddev = std::sqrt(variance);
    double q3 = xs[(3*n)/4];
    double q1 = xs[n/4];

    if(csvout) {
        printf("%d,%lg,%lg,%lg,%lg,%lg,%lg,%lg\n", n_victims, mean, xs.back(),
            xs[int(0.9*n)], q3, xs[n/2], stddev, q3-q1);
    }
    else {
        printf("%3d %11s: mean: %lf, max: %lf, 90p: %lf, 75p: %lf, 50p: %lf, stddev: %lf, iqd: %lf\n",
            n_victims, name, mean, xs.back(), xs[int(0.9*n)], q3, xs[n/2], stddev, q3 - q1);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
movq (%rdx), %r12
movq 0x8(%rdx), %r13
cmpq %r13, %r12
je 0xc579
movq %r13, %rax
subq %r12, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0xdf06
movq %r12, %rdi
movq %r13, %rsi
callq 0xdfff
movq (%r15), %rax
movq 0x8(%r15), %r12
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
xorpd %xmm7, %xmm7
cmpq %r12, %rax
je 0xc5ad
movq %rax, %rcx
movsd (%rcx), %xmm2
addsd %xmm2, %xmm7
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
addq $0x8, %rcx
cmpq %r12, %rcx
jne 0xc594
subq %rax, %r12
shrq $0x3, %r12
cvtsi2sd %r12d, %xmm4
movapd %xmm7, %xmm2
mulsd %xmm7, %xmm2
divsd %xmm4, %xmm2
leal -0x1(%r12), %eax
cvtsi2sd %eax, %xmm3
subsd %xmm2, %xmm0
divsd %xmm3, %xmm0
ucomisd %xmm1, %xmm0
jb 0xc5e2
sqrtsd %xmm0, %xmm5
jmp 0xc603
movsd %xmm7, 0x10(%rsp)
movsd %xmm4, 0x8(%rsp)
callq 0x2150
movsd 0x8(%rsp), %xmm4
movsd 0x10(%rsp), %xmm7
movapd %xmm0, %xmm5
divsd %xmm4, %xmm7
leal (%r12,%r12,2), %eax
leal (%r12,%r12,2), %ecx
addl $0x3, %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x2, %ecx
movslq %ecx, %rax
movq (%r15), %rcx
movsd (%rcx,%rax,8), %xmm3
leal 0x3(%r12), %eax
testl %r12d, %r12d
cmovnsl %r12d, %eax
movq 0x8(%r15), %rdx
sarl $0x2, %eax
cltq
movsd -0x8(%rdx), %xmm1
mulsd 0x4101(%rip), %xmm4     # 0x10748
cvttsd2si %xmm4, %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm2
movl %r12d, %edx
shrl $0x1f, %edx
addl %r12d, %edx
sarl %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm4
movapd %xmm3, %xmm6
subsd (%rcx,%rax,8), %xmm6
testb %bpl, %bpl
je 0xc696
leaq 0x4443(%rip), %rdi      # 0x10abe
movl %ebx, %esi
movapd %xmm7, %xmm0
movb $0x7, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
leaq 0x4441(%rip), %rdi      # 0x10ade
movl %ebx, %esi
movq %r14, %rdx
movapd %xmm7, %xmm0
movb $0x7, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2090
leaq 0xa6cf(%rip), %rdi      # 0x16db0
movq %r14, %rsi
callq 0xe2e2
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc6ff
callq 0x21b0
leaq 0xa6b2(%rip), %rax      # 0x16db8
cmpq %rax, %r14
je 0xc717
movl 0x40(%r14), %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x98b2(%rip), %rax      # 0x15fd0
movq (%rax), %rdi
leaq 0x440a(%rip), %rsi      # 0x10b32
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2250
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xc70f
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc74f
callq 0x21b0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x34e1(%rip), %rsi      # 0x10c20
xorl %eax, %eax
callq 0x2250
leaq 0x8a83(%rip), %r15      # 0x161d0
leaq 0x34d6(%rip), %r14      # 0x10c2a
xorl %r12d, %r12d
movq (%r12,%r15), %rdx
movq 0x28(%r12,%r15), %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2250
addq $0xa0, %r12
cmpq $0xbe0, %r12            # imm = 0xBE0
jne 0xd757
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %r15
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r12d
movq %rdi, %rbx
leaq 0xf(%rsp), %rdx
callq 0x2090
movb %r12b, 0x20(%rbx)
leaq 0x28(%rbx), %rdi
leaq 0xe(%rsp), %rdx
movq %r14, %rsi
callq 0x2090
leaq 0x58(%rbx), %rdi
leaq 0xd(%rsp), %rdx
movq %r14, %rsi
callq 0x2090
movb %bpl, 0x78(%rbx)
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rdx
movq %r15, %rsi
callq 0x2090
movzbl 0x20(%rbx), %eax
cmpl $0x66, %eax
je 0xd823
cmpl $0x69, %eax
jne 0xd835
movq %r14, %rdi
callq 0x22a0
movl %eax, 0x50(%rbx)
movl %eax, 0x48(%rbx)
jmp 0xd835
movq %r14, %rdi
callq 0x2210
movsd %xmm0, 0x50(%rbx)
movsd %xmm0, 0x48(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x58(%rbx), %rdi
leaq 0x68(%rbx), %rax
cmpq %rax, %rdi
je 0xd85c
callq 0x21b0
jmp 0xd85c
movq %rax, %r14
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0xd873
callq 0x21b0
jmp 0xd873
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0xd884
callq 0x21b0
movq %r14, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ddos-on-anycast/src/simulate.cpp
// Function: ArgSpec::set_from_string(char const*)
void set_from_string(const char* s) {
        val_s = s;
        if(type == 'i') {
            val_i = coalesce(atoi(s), defval_i, zero_is_null);
        }
        else if(type == 'f') {
            val_f = coalesce(atof(s), defval_f, zero_is_null);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rdi), %r15
movq 0x60(%rdi), %r12
movq %rsi, %rdi
callq 0x20b0
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x2290
movzbl 0x20(%rbx), %eax
cmpl $0x66, %eax
je 0xd946
cmpl $0x69, %eax
jne 0xd975
movq %r14, %rdi
callq 0x22a0
movl 0x48(%rbx), %ecx
testl %eax, %eax
movl %eax, %edx
cmovlel %ecx, %edx
cmovsl %ecx, %eax
cmpb $0x0, 0x78(%rbx)
cmovnel %edx, %eax
movl %eax, 0x50(%rbx)
jmp 0xd975
movq %r14, %rdi
callq 0x2210
xorpd %xmm1, %xmm1
xorl %eax, %eax
xorl %ecx, %ecx
ucomisd %xmm0, %xmm1
setae %al
seta %cl
cmpb $0x0, 0x78(%rbx)
cmovnel %eax, %ecx
testb %cl, %cl
je 0xd970
movsd 0x48(%rbx), %xmm0
movsd %xmm0, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sharmaeklavya2[P]ddos-on-anycast/src/lib/graph_gen.hpp
// Function: NormalOrderGraphGen::operator()(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&, int)
virtual int operator()(ipvec& l, int seed) {
        rng_t rng(seed);
        rng_t rng2(rng());
        graph_gen.n = std::max(1, int(n * std::normal_distribution<double>(1.0, sigma)(rng2)));
        return graph_gen(l, rng());
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movslq %edx, %rcx
movabsq $0x200000005, %rdx      # imm = 0x200000005
movq %rcx, %rax
mulq %rdx
movq %rdi, %rbx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x1e, %rax
movq %rax, %rdx
shlq $0x1f, %rdx
subq %rdx, %rax
leaq (%rcx,%rax), %rdx
cmpq $0x1, %rdx
adcq %rcx, %rax
imulq $0xbc8f, %rax, %rcx     # imm = 0xBC8F
movabsq $0x800000010001, %r15   # imm = 0x800000010001
movq %rcx, %rax
mulq %r15
shrl $0xe, %edx
movq %rdx, %rax
shlq $0x1f, %rax
subq %rax, %rdx
leaq (%rcx,%rdx), %r12
cmpq $0x1, %r12
adcq %rcx, %rdx
leaq 0x10(%rsp), %rax
movq %rdx, (%rax)
cvtsi2sdl 0x8(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r14
movsd 0x10(%rdi), %xmm0
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
leaq 0x18(%rsp), %rdi
movq %rcx, (%rdi)
movsd %xmm0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq %rax, %rsi
movq %rdi, %rdx
callq 0x638a
mulsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %eax
cmpl $0x2, %eax
movl $0x1, %esi
cmovgel %eax, %esi
movq 0x18(%rbx), %rdi
imulq $0xbc8f, %r12, %rcx     # imm = 0xBC8F
movq %rcx, %rax
mulq %r15
movl %esi, 0x8(%rdi)
shrl $0xe, %edx
movl %edx, %eax
shll $0x1f, %eax
orl %eax, %edx
addl %ecx, %edx
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/Server.cpp
// Function: ratabase::Server::Server(int)
Server::Server(int port):
    port_(port)
{
    serverInit();
    rm_ = std::unique_ptr<RatabaseManager>(new RatabaseManager());
    parser_ = std::unique_ptr<Parser>(new Parser());
    LOG_DEBUG << "ctor[" << this << "]";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %r15
movl %esi, (%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x18(%rdi), %r14
leaq 0x38(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq %rax, 0x28(%rdi)
xorl %eax, %eax
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movb %al, 0x58(%rdi)
movups %xmm0, 0x68(%rdi)
movq %rax, 0x78(%rdi)
callq 0x592c
movl $0x190, %edi            # imm = 0x190
callq 0x3300
movq %rax, %r13
movq %rax, %rdi
callq 0x752c
movq %rbx, %rdi
movq %r13, %rsi
callq 0x64c6
movl $0xd0, %edi
callq 0x3300
movq %rax, %r13
movq %rax, %rdi
callq 0x654c
movq %r14, %rdi
movq %r13, %rsi
callq 0x64e6
callq 0xbc5a
cmpl $0x1, %eax
jg 0x58d0
leaq 0x77f7(%rip), %rsi      # 0xd05d
leaq 0x7802(%rip), %rcx      # 0xd06f
leaq 0x8(%rsp), %rdi
movl $0x1b, %edx
movl $0x1, %r8d
callq 0xb910
leaq 0x8(%rsp), %rdi
callq 0xbc72
movq %rax, %r12
addq $0x10, %r12
leaq 0x77ce(%rip), %rsi      # 0xd068
movl $0x5, %edx
movq %r12, %rdi
callq 0x3340
movq %r12, %rdi
movq %r15, %rsi
callq 0x3260
leaq 0x7ef8(%rip), %rsi      # 0xd7b1
movl $0x1, %edx
movq %rax, %rdi
callq 0x3340
leaq 0x8(%rsp), %rdi
callq 0xbb24
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5905
jmp 0x58e7
jmp 0x5905
movq %rax, %r12
movq %r13, %rdi
callq 0x32d0
jmp 0x5908
jmp 0x5905
movq %rax, %r12
leaq 0x8(%rsp), %rdi
callq 0xbb24
jmp 0x5908
movq %rax, %r12
addq $0x20, %r15
movq %r15, %rdi
callq 0x6492
movq %r14, %rdi
callq 0x6464
movq %rbx, %rdi
callq 0x6436
movq %r12, %rdi
callq 0x34d0