LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/andrakis[P]alisp/contrib/linenoise-ng/src/ConvertUTF.cpp
// Function: linenoise_ng::isLegalUTF8(unsigned char const*, int)
static Boolean isLegalUTF8(const UTF8 *source, int length) {
    UTF8 a;
    const UTF8 *srcptr = source+length;
    switch (length) {
    default: return false;
        /* Everything else falls through when "true"... */
    case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
    case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
    case 2: if ((a = (*--srcptr)) > 0xBF) return false;

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

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

// Assembly:
leal -0x1(%rsi), %ecx
cmpl $0x3, %ecx
ja 0xf849
movslq %esi, %rax
addq %rdi, %rax
leaq 0x10fe6(%rip), %rdx     # 0x20800
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movb (%rdi), %al
cmpb $-0x3e, %al
jl 0xf849
cmpb $-0xb, %al
setb %al
retq
cmpb $-0x41, -0x1(%rax)
jg 0xf849
decq %rax
cmpb $-0x41, -0x1(%rax)
jg 0xf849
decq %rax
movb -0x1(%rax), %cl
cmpb $-0x41, %cl
jbe 0xf84c
xorl %eax, %eax
retq
movb (%rdi), %al
movzbl %al, %edx
cmpl $0xef, %edx
jg 0xf872
cmpl $0xe0, %edx
je 0xf891
cmpl $0xed, %edx
jne 0xf88b
movb $-0x13, %al
cmpb $-0x61, %cl
jbe 0xf829
jmp 0xf849
cmpl $0xf0, %edx
je 0xf89a
cmpl $0xf4, %edx
jne 0xf88b
movb $-0xc, %al
cmpb $-0x71, %cl
jbe 0xf829
jmp 0xf849
testb %cl, %cl
jns 0xf849
jmp 0xf825
movb $-0x20, %al
cmpb $-0x60, %cl
jae 0xf829
jmp 0xf849
movb $-0x10, %al
cmpb $-0x70, %cl
jae 0xf829
jmp 0xf849
// File: /workspace/github_cpp_makefile_star2_O3/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: linenoiseHistoryFree
void linenoiseHistoryFree(void) {
  if (history) {
    for (int j = 0; j < historyLen; ++j) free(history[j]);
    historyLen = 0;
    free(history);
    history = 0;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x1e944(%rip), %rbx     # 0x2e680
testq %rbx, %rbx
je 0xfd7e
movslq 0x1e940(%rip), %r14     # 0x2e688
testq %r14, %r14
jle 0xfd61
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x7410
incq %r15
cmpq %r15, %r14
jne 0xfd50
movl $0x0, 0x1e91d(%rip)     # 0x2e688
movq %rbx, %rdi
callq 0x7410
movq $0x0, 0x1e902(%rip) # 0x2e680
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: write32(int, char32_t*, int)
static int write32(int fd, char32_t* text32, int len32) {
#ifdef _WIN32
  if (isatty(fd)) {
    size_t len16 = 2 * len32 + 1;
    unique_ptr<char16_t[]> text16(new char16_t[len16]);
    size_t count16 = WinWrite32(text16.get(), text32, len32);

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

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

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

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

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xfdb2(%rip), %rsi      # 0x20b81
movl $0x7, %edx
movl $0x1, %edi
callq 0x7130
movq 0x8(%rbx), %rdi
movl 0x1c(%rbx), %esi
callq 0x101e3
cmpl $-0x1, %eax
je 0x10e39
cmpl $0x0, 0x24(%rbx)
sete %cl
movl 0x20(%rbx), %eax
testl %eax, %eax
setg %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x10e24
leaq 0xfe22(%rip), %rsi      # 0x20c2e
movl $0x1, %edx
movl $0x1, %edi
callq 0x7130
cmpq $-0x1, %rax
je 0x10e39
movl 0x20(%rbx), %eax
movl %eax, 0x30(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfd84
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: linenoiseHistoryAdd
int linenoiseHistoryAdd(const char* line) {
  if (historyMaxLen == 0) {
    return 0;
  }
  if (history == NULL) {
    history =
        reinterpret_cast<char8_t**>(malloc(sizeof(char8_t*) * historyMaxLen));
    if (history == NULL) {
      return 0;
    }
    memset(history, 0, (sizeof(char*) * historyMaxLen));
  }
  char8_t* linecopy = strdup8(line);
  if (!linecopy) {
    return 0;
  }

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl 0x1b4c4(%rip), %r15d    # 0x2e384
movq 0x1b7b9(%rip), %rbx     # 0x2e680
testq %rbx, %rbx
jne 0x12ef1
leaq (,%r15,8), %rsi
movl $0x1, %edi
callq 0x7220
movq %rax, %rbx
movq %rax, 0x1b798(%rip)     # 0x2e680
testq %rax, %rax
je 0x12f95
movq %r14, %rdi
callq 0x7660
xorl %ebp, %ebp
testq %rax, %rax
je 0x12fa1
movq %rax, %r14
movzbl (%rax), %ecx
cmpl $0xa, %ecx
je 0x12f15
testl %ecx, %ecx
jne 0x12f18
jmp 0x12f1d
movb $0x20, (%rax)
incq %rax
jmp 0x12f07
movslq 0x1b764(%rip), %r12     # 0x2e688
testq %r12, %r12
jle 0x12f3f
movq -0x8(%rbx,%r12,8), %rdi
testq %rdi, %rdi
je 0x12f3f
movq %r14, %rsi
callq 0x74e0
testl %eax, %eax
je 0x12f99
cmpl %r15d, %r12d
jne 0x12f7f
movq (%rbx), %rdi
callq 0x7410
leaq 0x8(%rbx), %rsi
decl %r15d
leaq (,%r15,8), %rdx
movq %rbx, %rdi
callq 0x75c0
movl 0x1b417(%rip), %eax     # 0x2e380
leal -0x1(%rax), %ecx
testl %eax, %eax
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmovnsl %ecx, %eax
movl %eax, 0x1b404(%rip)     # 0x2e380
movl %r15d, %r12d
movslq %r12d, %rax
movq %r14, (%rbx,%rax,8)
incl %eax
movl %eax, 0x1b6fa(%rip)     # 0x2e688
movl $0x1, %ebp
jmp 0x12fa1
xorl %ebp, %ebp
jmp 0x12fa1
movq %r14, %rdi
callq 0x7410
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: linenoiseHistorySetMaxLen
int linenoiseHistorySetMaxLen(int len) {
  if (len < 1) {
    return 0;
  }
  if (history) {
    int tocopy = historyLen;
    char8_t** newHistory =
        reinterpret_cast<char8_t**>(malloc(sizeof(char8_t*) * len));
    if (newHistory == NULL) {
      return 0;
    }
    if (len < tocopy) {
      tocopy = len;
    }
    memcpy(newHistory, history + historyMaxLen - tocopy,
           sizeof(char8_t*) * tocopy);
    free(history);
    history = newHistory;
  }
  historyMaxLen = len;
  if (historyLen > historyMaxLen) {
    historyLen = historyMaxLen;
  }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebp, %ebp
testl %edi, %edi
jle 0x1354f
movl %edi, %ebx
movq 0x1b19a(%rip), %r14     # 0x2e680
movl 0x1b19b(%rip), %r12d    # 0x2e688
testq %r14, %r14
je 0x13539
movl %ebx, %edi
shlq $0x3, %rdi
callq 0x74b0
testq %rax, %rax
je 0x1354f
movq %rax, %r15
cmpl %ebx, %r12d
movl %ebx, %eax
cmovll %r12d, %eax
movl 0x1ae70(%rip), %ecx     # 0x2e384
leaq (%r14,%rcx,8), %rsi
movslq %eax, %rdx
shlq $0x3, %rdx
subq %rdx, %rsi
movq %r15, %rdi
callq 0x72b0
movq %r14, %rdi
callq 0x7410
movq %r15, 0x1b147(%rip)     # 0x2e680
movl %ebx, 0x1ae45(%rip)     # 0x2e384
movl $0x1, %ebp
cmpl %ebx, %r12d
jle 0x1354f
movl %ebx, 0x1b139(%rip)     # 0x2e688
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/andrakis[P]alisp/contrib/linenoise-ng/src/linenoise.cpp
// Function: linenoiseHistorySave
int linenoiseHistorySave(const char* filename) {
#if _WIN32
  FILE* fp = fopen(filename, "wt");
#else
  int fd = open(filename, O_CREAT | O_TRUNC | O_WRONLY, S_IRUSR | S_IWUSR);

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

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

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

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

  fclose(fp);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x241, %esi            # imm = 0x241
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x7280
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x13605
leaq 0xd662(%rip), %rsi      # 0x20c05
movl %eax, %edi
callq 0x7380
testq %rax, %rax
je 0x13605
movq %rax, %rbx
movl 0x1b0d0(%rip), %eax     # 0x2e688
testl %eax, %eax
jle 0x135fb
movq 0x1b0bd(%rip), %rcx     # 0x2e680
leaq 0xd63e(%rip), %r14      # 0x20c08
xorl %r15d, %r15d
movq (%rcx,%r15,8), %rdx
cmpb $0x0, (%rdx)
je 0x135f0
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x7500
movq 0x1b096(%rip), %rcx     # 0x2e680
movl 0x1b098(%rip), %eax     # 0x2e688
incq %r15
movslq %eax, %rdx
cmpq %rdx, %r15
jl 0x135cd
movq %rbx, %rdi
callq 0x7300
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xccc3(%rip), %rsi      # 0x202e6
callq 0x7400
testq %rax, %rax
je 0x1368a
movq %rax, %rbx
movq %rsp, %r14
movq %r14, %rdi
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdx
callq 0x7570
testq %rax, %rax
je 0x1367e
movq %r14, %rdi
movl $0xd, %esi
callq 0x7150
testq %rax, %rax
jne 0x1366c
movq %r14, %rdi
movl $0xa, %esi
callq 0x7150
testq %rax, %rax
je 0x13674
movb $0x0, (%rax)
cmpq %r14, %rax
je 0x13633
movq %r14, %rdi
callq 0x12eae
jmp 0x13633
movq %rbx, %rdi
callq 0x7300
xorl %eax, %eax
jmp 0x1368f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd699(%rip), %rdi      # 0x20d46
callq 0x7540
callq 0x11b2f
cmpl $-0x1, %eax
je 0x13778
leaq 0x5(%rsp), %r15
movl $0x20202020, -0x1(%r15) # imm = 0x20202020
leaq 0x3(%rsp), %rbx
movl $0x3f, %r12d
leaq 0xd52d(%rip), %r14      # 0x20c0c
movq 0x1a89a(%rip), %r13     # 0x2df80
movl $0x1, %edx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x7510
testl %eax, %eax
jle 0x136e6
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 0x13750
movl %ebp, %edi
callq 0x7640
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 0x74d0
movq (%r13), %rdi
callq 0x73f0
jmp 0x136e6
cmpb $0x1, 0x1afa9(%rip)     # 0x2e700
jne 0x13778
leaq 0x1afa4(%rip), %rdx     # 0x2e704
xorl %edi, %edi
movl $0x1, %esi
callq 0x7470
cmpl $-0x1, %eax
je 0x13778
movb $0x0, 0x1af88(%rip)     # 0x2e700
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7450
movl $0x0, 0x80(%rbx)
leaq 0x2e(%rip), %rax        # 0x137db
movq %rax, -0x8(%rbx)
xorl %ebx, %ebx
leaq 0x8(%rsp), %rsi
movl $0x1c, %edi
xorl %edx, %edx
callq 0x7460
cmpl $-0x1, %eax
jne 0x137d0
callq 0x7060
movl (%rax), %ebx
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfb8a
testl %eax, %eax
jne 0x13852
movq (%rsp), %rcx
movq %rcx, %rdx
subq %r15, %rdx
sarq $0x2, %rdx
movq %rdx, (%r14)
cmpq %rbx, %rdx
jae 0x13852
movl $0x0, (%rcx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfa55
testl %eax, %eax
jne 0x138ac
movq (%rsp), %rax
movq %rax, %rcx
subq %r15, %rcx
movq %rcx, (%r14)
cmpq %rbx, %rcx
jae 0x138ac
movb $0x0, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x7(%rsp), %rbx
leaq 0x1ae1f(%rip), %r14     # 0x2e6ec
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movl $0x1, %edx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x7510
cmpq $-0x1, %rax
jne 0x138f8
callq 0x7060
cmpl $0x4, (%rax)
je 0x138d7
jmp 0x13956
testq %rax, %rax
jle 0x13956
movsbl 0x7(%rsp), %eax
testl %eax, %eax
jns 0x13964
movq 0x1adeb(%rip), %rcx     # 0x2e6f8
cmpq $0x3, %rcx
ja 0x13949
leaq 0x1(%rcx), %rdx
movq %rdx, 0x1adda(%rip)     # 0x2e6f8
movb %al, (%rcx,%r14)
movb $0x0, 0x1(%rcx,%r14)
movl $0x2, %esi
movq %r15, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x137ea
testl %eax, %eax
jne 0x138d7
cmpq $0x0, 0x8(%rsp)
je 0x138d7
jmp 0x13971
movq $0x0, 0x1ada4(%rip) # 0x2e6f8
jmp 0x138d7
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq $0x0, 0x1ad89(%rip) # 0x2e6f8
jmp 0x13958
movq $0x0, 0x1ad7c(%rip) # 0x2e6f8
movl 0x10(%rsp), %eax
jmp 0x13958
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
movl $0x40000000, 0x1aca1(%rip) # imm = 0x40000000
movl $0x1, %ecx
leaq 0x1980d(%rip), %rax     # 0x2d260
cmpl $0x7f, %edi
je 0x13a87
cmpl $0x1b, %edi
jne 0x13a82
callq 0x138b6
movl %eax, %edi
testl %eax, %eax
je 0x13a8e
leaq 0x19809(%rip), %rax     # 0x2d278
cmpl $0x4f, %edi
movl $0x1, %ecx
je 0x13a87
cmpl $0x5b, %edi
jne 0x13a82
xorl %ecx, %ecx
jmp 0x13a87
movl $0x2, %ecx
movq (%rax), %rax
popq %rdx
jmpq *(%rax,%rcx,8)
movl %edi, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x138b6
testl %eax, %eax
je 0x13cf7
orb $0x40, 0x1aa20(%rip)    # 0x2e6eb
xorl %ecx, %ecx
leaq 0xcfcc(%rip), %rdx      # 0x20ca0
movzbl (%rcx,%rdx), %esi
cmpl %esi, %eax
je 0x13cea
incq %rcx
cmpq $0x4, %rcx
jne 0x13cd4
movl $0x4, %ecx
leaq 0x1965f(%rip), %rdx     # 0x2d350
movl %eax, %edi
popq %rax
jmpq *(%rdx,%rcx,8)
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x138b6
testl %eax, %eax
je 0x13d38
orb $0x20, 0x1a9df(%rip)    # 0x2e6eb
xorl %ecx, %ecx
leaq 0xcf8b(%rip), %rdx      # 0x20ca0
movzbl (%rcx,%rdx), %esi
cmpl %esi, %eax
je 0x13d2b
incq %rcx
cmpq $0x4, %rcx
jne 0x13d15
movl $0x4, %ecx
leaq 0x1961e(%rip), %rdx     # 0x2d350
movl %eax, %edi
popq %rax
jmpq *(%rdx,%rcx,8)
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x14b16
movl (%r14), %eax
movl %eax, 0x58(%rbx)
leaq 0x40(%rbx), %rdi
movq %r14, %rsi
callq 0x142ba
movq %rbx, %rdi
callq 0x14178
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14156
callq 0x7490
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14170
callq 0x7490
movq %rbx, %rdi
callq 0x7630
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a46c(%rip), %rax     # 0x2e600
leaq 0x1a475(%rip), %rcx     # 0x2e610
cmovgq %rax, %rcx
movq (%rcx), %rbp
movslq 0x58(%rdi), %rax
movq %rax, 0x8(%rsp)
movl %eax, %eax
leaq 0x1a454(%rip), %rcx     # 0x2e608
leaq 0x1a45d(%rip), %r12     # 0x2e618
cmovgq %rcx, %r12
movq 0x1a45a(%rip), %rcx     # 0x2e620
movq %rcx, 0x10(%rsp)
addq %rcx, %rax
addq %rbp, %rax
movl %eax, 0x18(%rdi)
movl %eax, 0x1c(%rdi)
leaq 0x4(,%rax,4), %rcx
movabsq $0x3fffffffc, %r15      # imm = 0x3FFFFFFFC
andq %rcx, %r15
cmpl $-0x1, %eax
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, 0x20(%rsp)
movq (%r12), %rsi
leaq (,%rbp,4), %rdx
movq %r14, %rdi
callq 0x72b0
leaq (%r14,%rbp,4), %r15
movq 0x48(%rbx), %rsi
movq 0x8(%rsp), %r12
leaq (,%r12,4), %rdx
movq %r15, %rdi
callq 0x72b0
leaq (%r15,%r12,4), %rdi
movq 0x1a3d5(%rip), %rsi     # 0x2e628
movq 0x10(%rsp), %rax
leaq 0x4(,%rax,4), %rdx
callq 0x72b0
cmpl $0x0, 0x4(%r14,%r13,4)
leaq 0x1(%r13), %r13
jne 0x14265
leaq 0x18(%rsp), %rsi
movq %r13, (%rsi)
movq %rbx, %rdi
callq 0x142ba
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x14290
callq 0x7490
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x142b1
callq 0x7490
movq %rbx, %rdi
callq 0x7630
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1432a
movq %rsi, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x142de
callq 0x7490
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 0x72b0
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_O3/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 0x137ea
movq (%r14), %r14
testl %r14d, %r14d
jle 0x14859
movq (%rbx), %r15
movq 0x8(%rbx), %r12
movl %r14d, %r13d
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
movl (%r15,%rbp,4), %edi
callq 0x150f0
movb %al, (%r12,%rbp)
incq %rbp
cmpq %rbp, %r13
jne 0x14844
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_O3/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 0x14b2d
movq %r15, (%r14)
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %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)
shlq $0x2, %r15
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x72b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x15231
movl %edx, %ecx
cmpl %edi, 0x4(%rsi,%rcx,8)
setb %cl
testl %edx, %edx
sets %r8b
orb %cl, %r8b
jne 0x15231
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 0x15221
incl %ecx
movl %ecx, %eax
jmp 0x1522b
cmpl %edi, (%rsi,%r8,8)
jbe 0x15232
decl %ecx
movl %ecx, %edx
cmpl %eax, %edx
jge 0x15202
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1526f
movq %rsi, %r14
xorl %r12d, %r12d
xorl %ebx, %ebx
cmpq %r12, %r14
je 0x15278
callq 0x150f0
testl %eax, %eax
js 0x15273
addl %eax, %ebx
movl 0x4(%r15,%r12,4), %edi
incq %r12
testl %edi, %edi
jne 0x15251
jmp 0x15278
xorl %ebx, %ebx
jmp 0x15278
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_O3/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 0x152e4
movq %rsi, %r14
xorl %r12d, %r12d
xorl %ebx, %ebx
cmpq %r12, %r14
je 0x152ed
callq 0x15286
testl %eax, %eax
js 0x152e8
addl %eax, %ebx
movl 0x4(%r15,%r12,4), %edi
incq %r12
testl %edi, %edi
jne 0x152c6
jmp 0x152ed
xorl %ebx, %ebx
jmp 0x152ed
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x8(%rsp), %rsi
movq %rdx, (%rsi)
movq %r15, %rdi
callq 0x168fe
testq %rax, %rax
je 0x164cb
movq 0x10(%rax), %rsi
testq %rsi, %rsi
je 0x164e1
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *(%rax)
movq 0x8(%rsp), %rax
jmp 0x164e3
movq 0x38(%r15), %rsi
testq %rsi, %rsi
je 0x164f3
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1648a
jmp 0x164e6
xorl %eax, %eax
movq %rax, (%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 0x16828
leaq 0x16f3e(%rip), %rsi     # 0x2d450
leaq -0xb7f9(%rip), %rdx     # 0xad20
movq %r15, %rdi
callq 0x7600
movq %rdx, %r14
movq %rax, %rbx
movq %r15, %rdi
callq 0x7270
jmp 0x16537
movq %rdx, %r14
movq %rax, %rbx
movq %rbx, %rdi
testl %r14d, %r14d
jns 0x16544
callq 0x7480
callq 0x7630
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
callq 0x168fe
testq %rax, %rax
je 0x16587
movq (%r15), %rsi
testq %rsi, %rsi
je 0x165a9
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *(%rax)
movq 0x8(%rsp), %rax
jmp 0x165ab
movq 0x38(%r14), %r14
testq %r14, %r14
je 0x16603
movq (%r15), %rsi
testq %rsi, %rsi
je 0x165d4
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *(%rax)
movq 0x8(%rsp), %rax
jmp 0x165d6
xorl %eax, %eax
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
movq %r14, %rdi
callq 0xad8e
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0xad50
movq 0x10(%rsp), %rdi
jmp 0x165ee
xorl %eax, %eax
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1654a
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x165f9
movq (%rdi), %rax
callq *0x10(%rax)
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 0x16828
leaq 0x16e2e(%rip), %rsi     # 0x2d450
leaq -0xb909(%rip), %rdx     # 0xad20
movq %r15, %rdi
callq 0x7600
movq %rdx, %r14
movq %rax, %rbx
movq %r15, %rdi
callq 0x7270
jmp 0x16689
movq %rdx, %r14
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x16657
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x18(%rsp)
jmp 0x16689
movq %rdx, %r14
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x16678
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x10(%rsp)
jmp 0x16689
movq %rdx, %r14
movq %rax, %rbx
movq %rbx, %rdi
testl %r14d, %r14d
jns 0x16696
callq 0x7480
callq 0x7630
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17ce4
movq %rdx, %rbx
movq (%rdx), %r13
cmpq 0x8(%rdx), %r13
je 0x17ce4
movq %rsi, %r14
addq $0x8, %r13
leaq 0x8(%rsp), %r15
movq %r12, %rdi
callq 0xac7e
movq %rax, %rbp
movq -0x8(%r13), %rsi
testq %rsi, %rsi
je 0x17c93
movq (%rsi), %rax
movq %r15, %rdi
callq *(%rax)
movq 0x8(%rsp), %rax
jmp 0x17c95
xorl %eax, %eax
movq %rax, (%rsp)
movq %rbp, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0xad8e
movq %rax, %rdi
movq %rsp, %rsi
callq 0xad50
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x17cc5
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, (%rsp)
addq $0x8, %r12
cmpq 0x8(%r14), %r12
je 0x17ce4
leaq 0x8(%r13), %rax
cmpq 0x8(%rbx), %r13
movq %rax, %r13
jne 0x17c70
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 0x17d05
movq (%rdi), %rax
callq *0x10(%rax)
movq %rbx, %rdi
callq 0x7630
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movsbl (%rsi), %eax
cmpl $0x22, %eax
jne 0x180a1
movq 0x8(%r14), %rcx
cmpb $0x22, -0x1(%rsi,%rcx)
jne 0x18140
addq $-0x2, %rcx
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
movq %r14, %rsi
callq 0x7360
movq %rsp, %rdi
leaq 0x28(%rsp), %rsi
callq 0xa8b0
movq (%rsp), %rax
movq %rax, (%rbx)
movq $0x0, (%rsp)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18148
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7330
jmp 0x18148
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jae 0x180e0
movq %rsp, %rdi
movq %r14, %rsi
callq 0xdde5
cmpb $0x1, 0x8(%rsp)
jne 0x180f2
movq (%rsp), %r14
movl $0x18, %edi
callq 0x7310
movl $0x2, 0x8(%rax)
leaq 0x15669(%rip), %rcx     # 0x2d740
movq %rcx, (%rax)
movq %r14, 0x10(%rax)
jmp 0x18138
cmpb $0x2d, %al
jne 0x18140
movsbl 0x1(%rsi), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
jbe 0x180a9
jmp 0x18140
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0xdeee
cmpb $0x0, 0x20(%rsp)
je 0x1813d
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movl $0x18, %edi
callq 0x7310
movl $0x3, 0x8(%rax)
leaq 0x15746(%rip), %rcx     # 0x2d870
movq %rcx, (%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movq %rax, (%rbx)
jmp 0x18148
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xe6ec
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x18180
jmp 0x18180
jmp 0x18180
movq %rdx, %r14
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18186
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7330
jmp 0x18186
jmp 0x18180
jmp 0x18180
movq %rdx, %r14
movq %rax, %rbx
movq %rbx, %rdi
testl %r14d, %r14d
jns 0x18193
callq 0x7480
callq 0x7630
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x153b3(%rip)     # 0x2e8b0
jne 0x19528
pushq %rax
callq 0x13787
movq 0x14f14(%rip), %rdi     # 0x2e420
callq 0x13612
leaq -0x316(%rip), %rdi      # 0x19202
callq 0x13474
movb $0x1, 0x1538c(%rip)     # 0x2e8b0
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x20(%rsp)
movq (%rsi), %r15
cmpq 0x8(%rsi), %r15
je 0x1b942
movq %rsi, %r14
leaq 0x10(%rsp), %rbx
movq %rsp, %r12
movq 0x126de(%rip), %r13     # 0x2dfc8
leaq 0x5396(%rip), %rbp      # 0x20c87
cmpq (%r14), %r15
je 0x1b906
movl $0x1, %edx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x73d0
movq %r12, %rdi
movq %r15, %rsi
callq 0xac9c
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r13, %rdi
callq 0x73d0
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x1b938
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7330
addq $0x8, %r15
cmpq 0x8(%r14), %r15
jne 0x1b8f1
movq 0x1267f(%rip), %r14     # 0x2dfc8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x72e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7240
leaq 0x12dd1(%rip), %rax     # 0x2e748
movq (%rax), %rsi
testq %rsi, %rsi
je 0x1b98f
movq (%rsi), %rax
movq %rsp, %r14
movq %r14, %rdi
callq *(%rax)
movq (%r14), %rcx
jmp 0x1b991
xorl %ecx, %ecx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x1b9c1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7330
movq %r14, %rdi
callq 0x7630
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
cmpq %rcx, %rax
je 0x1c08d
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
subq %rax, %rcx
cmpq $0x10, %rcx
jne 0x1bfd1
movq 0x8(%rax), %rsi
testq %rsi, %rsi
je 0x1bff8
movq (%rsi), %rax
leaq 0x10(%rsp), %rdi
callq *(%rax)
movq 0x10(%rsp), %rax
jmp 0x1bffa
movq (%rdx), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rdx), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x1c005
movq 0x11fd2(%rip), %rcx     # 0x2dfc0
cmpb $0x0, (%rcx)
je 0x1c001
incl 0x8(%rax)
jmp 0x1c005
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x1c05f
lock
incl 0x8(%rax)
leaq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xa4a2
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq %rax, 0x8(%rsp)
testq %rdi, %rdi
je 0x1c047
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c047
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1c05f
callq 0xac0e
movq (%r14), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x15588
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1c07f
movq (%rdi), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x71b0
movq %rax, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x1289e(%rip), %rsi     # 0x2e948
movq 0x1289f(%rip), %rdx     # 0x2e950
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0xb0ca
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xacd6
xorl %ebp, %ebp
leaq 0x10be9(%rip), %rsi     # 0x2ccc0
leaq -0x113be(%rip), %rdx    # 0xad20
movq %rbx, %rdi
callq 0x7600
movq %rax, %r14
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1c12b
callq 0xac0e
jmp 0x1c12b
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c114
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7330
testb %bpl, %bpl
jne 0x1c11e
jmp 0x1c13b
movq %rax, %r14
movq %rbx, %rdi
callq 0x7270
jmp 0x1c13b
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1c13b
movq (%rdi), %rax
callq *0x10(%rax)
movq %r14, %rdi
callq 0x7630
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq (%rsi), %r15
movq 0x8(%rsi), %rax
cmpq %rax, %r15
je 0x1d31c
movq %rdi, %rbx
subq %r15, %rax
cmpq $0x8, %rax
jne 0x1d2c6
movq (%r15), %rsi
testq %rsi, %rsi
je 0x1d2e4
movq (%rsi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq *(%rax)
movq (%r14), %rax
jmp 0x1d2e6
movq %rsi, %r14
movq (%r15), %rsi
testq %rsi, %rsi
je 0x1d2f9
movq (%rsi), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq *(%rax)
movq (%r12), %rax
jmp 0x1d2fb
xorl %eax, %eax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
movq %rax, (%rbx)
addq $0x8, %r15
cmpq 0x8(%r14), %r15
je 0x1d2e9
leaq 0x8(%r15), %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1dfa0
movq %r12, %r15
jmp 0x1d302
movl $0x28, %edi
callq 0x71b0
movq %rax, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x11797(%rip), %rsi     # 0x2ead0
movq 0x11798(%rip), %rdx     # 0x2ead8
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0xb0ca
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xacd6
xorl %ebp, %ebp
leaq 0xf95a(%rip), %rsi      # 0x2ccc0
leaq -0x1264d(%rip), %rdx    # 0xad20
movq %rbx, %rdi
callq 0x7600
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d38f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x7330
testb %bpl, %bpl
jne 0x1d399
jmp 0x1d3bb
movq %rax, %r14
movq %rbx, %rdi
callq 0x7270
jmp 0x1d3bb
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1d3b4
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x7630