LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/minidump.c
// Function: print_minidump_system_info
void print_minidump_system_info(FILE *in)
{
  uint16_t cpu_arch = read_uint16(in);
  const char *cpu_arch_str = "???";

  switch (cpu_arch)
  {
    case 9: cpu_arch_str = "x64"; break;
    case 5: cpu_arch_str = "ARM"; break;
    case 6: cpu_arch_str = "Itanium"; break;
    case 0: cpu_arch_str = "x86"; break;
    case 0xffff: cpu_arch_str = "Unknown"; break;
  }

  printf("\n");
  printf("         cpu_arch: %u (%s)\n", cpu_arch, cpu_arch_str);
  printf("        cpu_level: %u\n", read_uint16(in));
  printf("     cpu_revision: %u\n", read_uint16(in));
  printf("         num_cpus: %u\n", read_uint8(in));
  printf("          os_type: %u\n", read_uint8(in));
  printf("     os_ver_major: %u\n", read_uint32(in));
  printf("     os_ver_minor: %u\n", read_uint32(in));
  printf("         os_build: %u\n", read_uint32(in));
  printf("      os_platform: %u\n", read_uint32(in));

  uint32_t ofs_service_pack = read_uint32(in);

  printf(" ofs_service_pack: %u", ofs_service_pack);
  print_minidump_string(in, ofs_service_pack);

  printf("    os_suite_mask: %u\n", read_uint16(in));
  printf("        reserved2: %u\n", read_uint16(in));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x17d0
movl %eax, %ecx
incl %ecx
cmpw $0xa, %cx
ja 0x2e23
movzwl %cx, %ecx
leaq 0x2856(%rip), %rdx      # 0x5670
movslq (%rdx,%rcx,4), %r14
addq %rdx, %r14
jmp 0x2e2a
leaq 0x1a33(%rip), %r14      # 0x485d
movzwl %ax, %ebp
movl $0xa, %edi
callq 0x1030
leaq 0x1a3f(%rip), %rdi      # 0x487d
movl %ebp, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x17d0
leaq 0x1a40(%rip), %rdi      # 0x4899
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x17d0
leaq 0x1a3f(%rip), %rdi      # 0x48b0
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x17f1
leaq 0x1a3e(%rip), %rdi      # 0x48c7
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x17f1
leaq 0x1a3d(%rip), %rdi      # 0x48de
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x178e
leaq 0x1a3c(%rip), %rdi      # 0x48f5
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x178e
leaq 0x1a3b(%rip), %rdi      # 0x490c
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x178e
leaq 0x1a3a(%rip), %rdi      # 0x4923
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x178e
leaq 0x1a39(%rip), %rdi      # 0x493a
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x178e
movl %eax, %ebp
leaq 0x1a36(%rip), %rdi      # 0x4951
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
movl %ebp, %esi
callq 0x29cb
movq %rbx, %rdi
callq 0x17d0
leaq 0x1a2a(%rip), %rdi      # 0x4967
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x17d0
leaq 0x1a29(%rip), %rdi      # 0x497e
movl %eax, %esi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/minidump.c
// Function: print_minidump_memory64_list
void print_minidump_memory64_list(FILE *in, struct memory_print_t *memory_print)
{
  uint64_t number_of_memory_ranges = read_uint64(in);
  uint64_t offset = read_uint64(in);
  uint64_t n;

  printf("\n");
  printf("  num_memory_ranges: %" PRId64 "\n", number_of_memory_ranges);
  printf("             offset: 0x%" PRIx64 "\n", offset);

  for (n = 0; n < number_of_memory_ranges; n++)
  {
    uint64_t start = read_uint64(in);
    uint64_t size = read_uint64(in);
    char mark = ' ';

    if (memory_print->start >= start &&
        memory_print->start < start + size)
    {
      memory_print->file_offset = offset + (memory_print->start - start);
      memory_print->region_start = start;
      memory_print->region_end = start + size - 1;
      mark = '*';
    }

    printf("         %c  0x%08" PRIx64 ": size=%" PRId64 "\n", mark, start, size);

    offset += size;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x16f4
movq %rax, %r15
movq %r14, %rdi
callq 0x16f4
movq %rax, %r12
movl $0xa, %edi
callq 0x1030
leaq 0x19fe(%rip), %rdi      # 0x4995
movq %r15, %rsi
xorl %eax, %eax
callq 0x1060
leaq 0x1a07(%rip), %rdi      # 0x49af
movq %r12, %rsi
xorl %eax, %eax
callq 0x1060
testq %r15, %r15
je 0x301e
movq %r14, %rdi
callq 0x16f4
movq %rax, %r13
movq %r14, %rdi
callq 0x16f4
movq %rax, %rbp
movq 0x8(%rbx), %rax
movl $0x20, %esi
cmpq %r13, %rax
jb 0x3002
movq %rbp, %rcx
addq %r13, %rcx
cmpq %rcx, %rax
jae 0x3002
movq %r12, %rdx
subq %r13, %rdx
addq %rax, %rdx
movq %rdx, (%rbx)
movq %r13, 0x20(%rbx)
decq %rcx
movq %rcx, 0x28(%rbx)
movl $0x2a, %esi
leaq 0x19c2(%rip), %rdi      # 0x49cb
movq %r13, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1060
addq %rbp, %r12
decq %r15
jne 0x2fb7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/minidump.c
// Function: print_minidump_misc_info
void print_minidump_misc_info(FILE *in)
{
  printf("\n");
  printf("           len_info: %u\n", read_uint32(in));
  printf("             flags1: %u\n", read_uint32(in));
  printf("         process_id: %u\n", read_uint32(in));
  printf("process_create_time: %u\n", read_uint32(in));
  printf("  process_user_time: %u\n", read_uint32(in));
  printf("process_kernel_time: %u\n", read_uint32(in));
  printf("        cpu_max_mhz: %u\n", read_uint32(in));
  printf("        cpu_cur_mhz: %u\n", read_uint32(in));
  printf("      cpu_limit_mhz: %u\n", read_uint32(in));
  printf(" cpu_max_idle_state: %u\n", read_uint32(in));
  printf(" cpu_cur_idle_state: %u\n", read_uint32(in));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xa, %edi
callq 0x1030
movq %rbx, %rdi
callq 0x178e
leaq 0x192f(%rip), %rdi      # 0x4b6a
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x178e
leaq 0x1930(%rip), %rdi      # 0x4b83
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x178e
leaq 0x1931(%rip), %rdi      # 0x4b9c
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x178e
leaq 0x1932(%rip), %rdi      # 0x4bb5
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x178e
leaq 0x1933(%rip), %rdi      # 0x4bce
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x178e
leaq 0x1934(%rip), %rdi      # 0x4be7
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x178e
leaq 0x1935(%rip), %rdi      # 0x4c00
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x178e
leaq 0x1936(%rip), %rdi      # 0x4c19
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x178e
leaq 0x1937(%rip), %rdi      # 0x4c32
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x178e
leaq 0x1938(%rip), %rdi      # 0x4c4b
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x178e
leaq 0x1939(%rip), %rdi      # 0x4c64
movl %eax, %esi
xorl %eax, %eax
popq %rbx
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/mikeakohn[P]print_pe/build/../src/minidump.c
// Function: print_minidump_thread_info_list
void print_minidump_thread_info_list(FILE *in)
{
  printf("\n");
  printf("     size_of_header: %u\n", read_uint32(in));
  printf("      size_of_entry: %u\n", read_uint32(in));
  printf("  number_of_entries: %u\n", read_uint32(in));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xa, %edi
callq 0x1030
movq %rbx, %rdi
callq 0x178e
leaq 0x1699(%rip), %rdi      # 0x49eb
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x178e
leaq 0x1913(%rip), %rdi      # 0x4c7d
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x178e
leaq 0x1914(%rip), %rdi      # 0x4c96
movl %eax, %esi
xorl %eax, %eax
popq %rbx
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/util.c
// Function: janet_core_cfuns_ext
void janet_core_cfuns_ext(JanetTable *env, const char *regprefix, const JanetRegExt *cfuns) {
    (void) regprefix;
    while (cfuns->name) {
        Janet fun = janet_wrap_cfunction(cfuns->cfun);
        janet_table_put(env, janet_csymbolv(cfuns->name), fun);
        janet_registry_put(cfuns->cfun, cfuns->name, regprefix, cfuns->source_file, cfuns->source_line);
        cfuns++;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdx), %r12
testq %r12, %r12
je 0x19b0a
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x28, %rbx
movabsq $-0x5800000000000, %rbp # imm = 0xFFFA800000000000
movq -0x20(%rbx), %r13
movabsq $-0x1800000000000, %rax # imm = 0xFFFE800000000000
orq %rax, %r13
movq %r12, %rdi
callq 0x16310
movq %r12, %rdi
movl %eax, %esi
callq 0x24b3c
orq %rbp, %rax
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x18739
movq -0x28(%rbx), %rsi
movq -0x20(%rbx), %rdi
movq -0x10(%rbx), %rcx
movl -0x8(%rbx), %r8d
movq %r14, %rdx
callq 0x306af
movq (%rbx), %r12
addq $0x28, %rbx
testq %r12, %r12
jne 0x19ab2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/asm.c
// Function: tup3
static const Janet *tup3(Janet x, Janet y, Janet z) {
    Janet *tup = janet_tuple_begin(3);
    tup[0] = x;
    tup[1] = y;
    tup[2] = z;
    return janet_tuple_end(tup);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x38, %esi
movl $0x4, %edi
callq 0x18605
movq %rax, %r12
movq $-0x1, 0x18(%rax)
movl $0x3, 0x10(%rax)
leaq 0x20(%rax), %r13
movq %r15, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
movq %r13, %rdi
movl $0x3, %esi
callq 0x445a2
movl %eax, 0x14(%r12)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/asm.c
// Function: tup4
static const Janet *tup4(Janet w, Janet x, Janet y, Janet z) {
    Janet *tup = janet_tuple_begin(4);
    tup[0] = w;
    tup[1] = x;
    tup[2] = y;
    tup[3] = z;
    return janet_tuple_end(tup);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x40, %esi
movl $0x4, %edi
callq 0x18605
movq %rax, %r13
movq $-0x1, 0x18(%rax)
movl $0x4, 0x10(%rax)
leaq 0x20(%rax), %rbp
movq %r12, 0x20(%rax)
movq %r15, 0x28(%rax)
movq %r14, 0x30(%rax)
movq %rbx, 0x38(%rax)
movq %rbp, %rdi
movl $0x4, %esi
callq 0x445a2
movl %eax, 0x14(%r13)
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/corelib.c
// Function: janet_core_env
JanetTable *janet_core_env(JanetTable *replacements) {
    /* Memoize core env, ignoring replacements the second time around. */
    if (NULL != janet_vm.core_env) {
        return janet_vm.core_env;
    }

    JanetTable *dict = janet_core_lookup_table(replacements);

    /* Unmarshal bytecode */
    Janet marsh_out = janet_unmarshal(
                          janet_core_image,
                          janet_core_image_size,
                          0,
                          dict,
                          NULL);

    /* Memoize */
    janet_gcroot(marsh_out);
    JanetTable *env = janet_unwrap_table(marsh_out);
    janet_vm.core_env = env;

    /* Invert image dict manually here. We can't do this in boot.janet as it
     * breaks deterministic builds */
    Janet lidv, midv;
    lidv = midv = janet_wrap_nil();
    janet_resolve(env, janet_csymbol("load-image-dict"), &lidv);
    janet_resolve(env, janet_csymbol("make-image-dict"), &midv);
    JanetTable *lid = janet_unwrap_table(lidv);
    JanetTable *mid = janet_unwrap_table(midv);
    for (int32_t i = 0; i < lid->capacity; i++) {
        const JanetKV *kv = lid->data + i;
        if (!janet_checktype(kv->key, JANET_NIL)) {
            janet_table_put(mid, kv->value, kv->key);
        }
    }

    return env;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %fs:0x0, %rax
movq -0x1ad0(%rax), %rcx
testq %rcx, %rcx
jne 0x267ff
leaq -0x1ae0(%rax), %rbx
movabsq $-0x77fffffffffff, %r13 # imm = 0xFFF8800000000001
movq %r14, %rdi
callq 0x26811
movq 0xa2078(%rip), %rdi     # 0xc8798
movq 0xa2079(%rip), %rsi     # 0xc87a0
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x26a24
movq %rax, %rbp
movq %rax, %rdi
callq 0x26aca
movabsq $0x7fffffffffff, %r14   # imm = 0x7FFFFFFFFFFF
andq %r14, %rbp
movq %rbp, 0x10(%rbx)
leaq 0x8(%rsp), %r15
movq %r13, (%r15)
leaq 0x10(%rsp), %r12
movq %r13, (%r12)
leaq 0x82fea(%rip), %rdi     # 0xa9752
movl $0xf, %esi
callq 0x24b3c
movq %rbp, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x26b46
leaq 0x82fdb(%rip), %rdi     # 0xa9762
movl $0xf, %esi
callq 0x24b3c
movq %rbp, (%rsp)
movq %rbp, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x26b46
movq (%r12), %r15
andq %r14, %r15
cmpl $0x0, 0x14(%r15)
jle 0x267fb
andq 0x8(%rsp), %r14
movl $0x8, %r12d
xorl %ebp, %ebp
movabsq $-0x800000000000, %rbx  # imm = 0xFFFF800000000000
decq %r13
movq 0x20(%r15), %rax
movq -0x8(%rax,%r12), %rdx
movq %rdx, %rcx
andq %rbx, %rcx
cmpq %r13, %rcx
je 0x267eb
movq (%rax,%r12), %rsi
movq %r14, %rdi
callq 0x18739
incq %rbp
movslq 0x14(%r15), %rax
addq $0x10, %r12
cmpq %rax, %rbp
jl 0x267cb
movq (%rsp), %rcx
movq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/emit.c
// Function: janetc_free_regnear
static void janetc_free_regnear(JanetCompiler *c, JanetSlot s, int32_t reg, JanetcRegisterTemp tag) {
    if (reg != s.index ||
            s.envindex >= 0 ||
            s.flags & (JANET_SLOT_CONSTANT | JANET_SLOT_REF)) {
        /* We need to free the temporary slot */
        janetc_regalloc_freetemp(&c->scope->ra, reg, tag);
    }
}

// Assembly:
cmpl %esi, 0x10(%rsp)
jne 0x28692
cmpl $0x0, 0x14(%rsp)
jns 0x28692
leaq 0x8(%rsp), %rax
testb $0x9, 0x12(%rax)
je 0x286c4
movq (%rdi), %rax
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
movl $0xfffffffe, %r8d       # imm = 0xFFFFFFFE
movl %edx, %ecx
roll %cl, %r8d
andl %r8d, 0x44(%rax)
cmpl $0xef, %esi
jg 0x286c4
movl %esi, %edx
sarl $0x5, %edx
movl %esi, %ecx
roll %cl, %edi
movq 0x30(%rax), %rax
movslq %edx, %rcx
andl %edi, (%rax,%rcx,4)
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/ev.c
// Function: janet_stream_getter
static int janet_stream_getter(void *p, Janet key, Janet *out) {
    JanetStream *stream = (JanetStream *)p;
    if (!janet_checktype(key, JANET_KEYWORD)) return 0;
    const JanetMethod *stream_methods = stream->methods;
    return janet_getmethod(janet_unwrap_keyword(key), stream_methods, out);
}

// Assembly:
movq %rsi, %rax
shrq $0x2f, %rax
cmpl $0x1fff6, %eax          # imm = 0x1FFF6
jne 0x28d00
movq 0x20(%rdi), %rax
movabsq $0x7fffffffffff, %rcx   # imm = 0x7FFFFFFFFFFF
andq %rcx, %rsi
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x1efdc
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/filewatch.c
// Function: cfun_filewatch_remove
static void janet_watcher_remove(JanetWatcher *watcher, const char *path) {
    if (watcher->stream == NULL) janet_panic("watcher closed");
    Janet check = janet_table_get(watcher->watch_descriptors, janet_cstringv(path));
    janet_assert(janet_checktype(check, JANET_NUMBER), "bad watch descriptor");
    int watch_handle = janet_unwrap_integer(check);
    int result;
    do {
        result = inotify_rm_watch(watcher->stream->handle, watch_handle);
    } while (result != -1 && errno == EINTR);
    if (result == -1) {
        janet_panicv(janet_ev_lasterr());
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x2, %edi
jne 0x31bef
movq %rsi, %rbx
leaq 0x91ad3(%rip), %rdx     # 0xc3618
movq %rsi, %rdi
xorl %esi, %esi
callq 0x20137
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1f81c
cmpq $0x0, (%r14)
je 0x31c04
movq %rax, %r15
movq 0x8(%r14), %r12
movq %rax, %rdi
callq 0x16310
movq %r15, %rdi
movl %eax, %esi
callq 0x1ef64
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
orq %rax, %rsi
movq %r12, %rdi
callq 0x20329
movq %rax, %xmm0
ucomisd %xmm0, %xmm0
setnp %cl
movabsq $0x7800000000000, %rdx  # imm = 0x7800000000000
testq %rdx, %rax
sete %al
orb %cl, %al
je 0x31c10
cvttsd2si %xmm0, %ebp
movq (%r14), %rax
movl (%rax), %edi
movl %ebp, %esi
callq 0x16b80
cmpl $-0x1, %eax
je 0x31be2
callq 0x16120
cmpl $0x4, (%rax)
je 0x31bbb
movq (%rbx), %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2c208
movq %rax, %rdi
callq 0x1e989
movl %edi, %edx
leaq 0x77600(%rip), %rdi     # 0xa91f8
movl $0x2, %esi
xorl %eax, %eax
callq 0x1967e
leaq 0x7ac8e(%rip), %rdi     # 0xac899
callq 0x188ee
callq 0x178df
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/inttypes.c
// Function: janet_is_int
JanetIntType janet_is_int(Janet x) {
    if (!janet_checktype(x, JANET_ABSTRACT)) return JANET_INT_NONE;
    const JanetAbstractType *at = janet_abstract_type(janet_unwrap_abstract(x));
    return (at == &janet_s64_type) ? JANET_INT_S64 :
           ((at == &janet_u64_type) ? JANET_INT_U64 :
            JANET_INT_NONE);
}

// Assembly:
movq %rdi, %rcx
shrq $0x2f, %rcx
xorl %eax, %eax
cmpl $0x1fffe, %ecx          # imm = 0x1FFFE
jne 0x329e0
movabsq $0x7fffffffffff, %rax   # imm = 0x7FFFFFFFFFFF
andq %rax, %rdi
movq -0x10(%rdi), %rax
xorl %ecx, %ecx
cmpq 0x955fc(%rip), %rax     # 0xc7fc8
sete %cl
addl %ecx, %ecx
cmpq 0x955f8(%rip), %rax     # 0xc7fd0
movl $0x1, %eax
cmovnel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/util.c
// Function: janet_core_def_sm
void janet_core_def_sm(JanetTable *env, const char *name, Janet x, const void *p, const void *sf, int32_t sl) {
    (void) sf;
    (void) sl;
    (void) p;
    Janet key = janet_csymbolv(name);
    janet_table_put(env, key, x);
    if (janet_checktype(x, JANET_CFUNCTION)) {
        janet_registry_put(janet_unwrap_cfunction(x), name, NULL, NULL, 0);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x16310
movq %rbx, %rdi
movl %eax, %esi
callq 0x24b3c
movabsq $-0x5800000000000, %rsi # imm = 0xFFFA800000000000
orq %rax, %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x18739
movq %r14, %rax
shrq $0x2f, %rax
cmpl $0x1fffd, %eax          # imm = 0x1FFFD
jne 0x34395
movabsq $0x7fffffffffff, %rax   # imm = 0x7FFFFFFFFFFF
andq %rax, %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
popq %rbx
popq %r14
popq %r15
jmp 0x306af
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/specials.c
// Function: janetc_unquote
static JanetSlot janetc_unquote(JanetFopts opts, int32_t argn, const Janet *argv) {
    (void) argn;
    (void) argv;
    janetc_cerror(opts.compiler, "cannot use unquote here");
    return janetc_cslot(janet_wrap_nil());
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsp), %rdi
leaq 0x5828a(%rip), %rsi     # 0xadeef
callq 0x2083b
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
movabsq $-0x77fffffffffff, %rax # imm = 0xFFF8800000000001
movq %rax, (%rbx)
movabsq $0x10002ffffffff, %rax  # imm = 0x10002FFFFFFFF
movq %rax, 0xc(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/build/c/shell.c
// Function: janet_line_getter
Janet janet_line_getter(int32_t argc, Janet *argv) {
    janet_arity(argc, 0, 3);
    const char *str = (argc >= 1) ? (const char *) janet_getstring(argv, 0) : "";
    JanetBuffer *buf = (argc >= 2) ? janet_getbuffer(argv, 1) : janet_buffer(10);
    gbl_complete_env = (argc >= 3) ? janet_gettable(argv, 2) : NULL;
    janet_line_get(str, buf);
    gbl_complete_env = NULL;

    Janet result;
    if (gbl_cancel_current_repl_form) {
        gbl_cancel_current_repl_form = 0;

        /* Signal that the user bailed out of the current form */
        result = janet_ckeywordv("cancel");
    } else {
        result = janet_wrap_buffer(buf);
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebp
xorl %esi, %esi
movl $0x3, %edx
callq 0x18d7b
testl %ebp, %ebp
jle 0x583bf
movq %r14, %rdi
xorl %esi, %esi
callq 0x1daec
movq %rax, %rbx
jmp 0x583c6
leaq 0x56056(%rip), %rbx     # 0xae41c
cmpl $0x2, %ebp
jl 0x583da
movq %r14, %rdi
movl $0x1, %esi
callq 0x1c98b
jmp 0x583e4
movl $0xa, %edi
callq 0x1c3f9
movq %rax, %r15
cmpl $0x3, %ebp
jl 0x583fe
movq %r14, %rdi
movl $0x2, %esi
callq 0x1f187
movq %rax, %r14
jmp 0x58401
xorl %r14d, %r14d
movq %fs:0x0, %rax
movq %rax, %r12
movq %rax, %r13
movq %r14, -0x1790(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x58497
movq $0x0, -0x1790(%r13)
movq %r12, %rax
cmpl $0x0, -0x1788(%r12)
je 0x58477
leaq -0x1788(%rax), %rax
movl $0x0, (%rax)
leaq 0x55e2d(%rip), %rdi     # 0xae27f
callq 0x1b640
movabsq $-0x5000000000000, %rsi # imm = 0xFFFB000000000000
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b639
movabsq $-0x2800000000000, %rsi # imm = 0xFFFD800000000000
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1886d
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/build/c/shell.c
// Function: janet_line_deinit
void janet_line_deinit() {
    int i;
    norawmode();
    for (i = 0; i < gbl_history_count; i++)
        janet_free(gbl_history[i]);
    gbl_historyi = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %fs:0x0, %rax
movq %rax, %rbx
cmpl $0x0, -0x1050(%rax)
je 0x592b3
movq %rax, %r14
leaq -0x104c(%rbx), %rdx
xorl %edi, %edi
movl $0x1, %esi
callq 0x16990
cmpl $-0x1, %eax
je 0x592b3
leaq -0x1050(%r14), %rax
movl $0x0, (%rax)
movslq -0x1784(%rbx), %r14
testq %r14, %r14
jle 0x592da
leaq -0x1780(%rbx), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
callq 0x160b0
incq %r12
cmpq %r12, %r14
jne 0x592c9
movl $0x0, -0x1460(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/build/c/shell.c
// Function: simpleline
static void simpleline(JanetBuffer *buffer) {
    FILE *in = janet_dynfile("in", stdin);
    buffer->count = 0;
    int c;
    for (;;) {
        c = fgetc(in);
        if (c < 0 && !feof(in) && errno == EINTR) {
            continue;
        }
        if (feof(in) || c < 0) {
            break;
        }
        janet_buffer_push_u8(buffer, (uint8_t) c);
        if (c == '\n') break;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x6ea97(%rip), %rax     # 0xc7f90
movq (%rax), %rsi
leaq 0x502bd(%rip), %rdi     # 0xa97c0
callq 0x26013
movq %rax, %r14
movl $0x0, 0x10(%rbx)
movq %r14, %rdi
callq 0x16450
movl %eax, %ebp
testl %eax, %eax
jns 0x59536
movq %r14, %rdi
callq 0x16630
testl %eax, %eax
jne 0x59536
callq 0x16120
cmpl $0x4, (%rax)
je 0x59512
movq %r14, %rdi
callq 0x16630
testl %ebp, %ebp
js 0x59557
testl %eax, %eax
jne 0x59557
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x1c643
cmpl $0xa, %ebp
jne 0x59512
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/build/c/shell.c
// Function: rawmode
static int rawmode(void) {
    struct termios t;
    if (!isatty(STDIN_FILENO)) goto fatal;
    if (tcgetattr(STDIN_FILENO, &gbl_termios_start) == -1) goto fatal;
    t = gbl_termios_start;
    t.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
    t.c_cflag |= (CS8);
    t.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
    t.c_cc[VMIN] = 1;
    t.c_cc[VTIME] = 0;
    if (tcsetattr(STDIN_FILENO, TCSADRAIN, &t) < 0) goto fatal;
    gbl_israwmode = 1;
    return 0;
fatal:
    errno = ENOTTY;
    return -1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
xorl %edi, %edi
callq 0x161c0
testl %eax, %eax
je 0x595ee
movq %fs:0x0, %rax
movq %rax, %rbx
leaq -0x104c(%rax), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x16980
cmpl $-0x1, %eax
je 0x595ee
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x2c(%r14), %xmm3
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movaps %xmm1, 0x10(%rdx)
movups %xmm3, 0x2c(%rdx)
andl $0xfffffacd, (%rdx)     # imm = 0xFFFFFACD
movaps %xmm2, 0x20(%rdx)
orb $0x30, 0x8(%rdx)
andl $0xffff7ff4, 0xc(%rdx)  # imm = 0xFFFF7FF4
movw $0x100, 0x16(%rdx)      # imm = 0x100
xorl %ebp, %ebp
xorl %edi, %edi
movl $0x1, %esi
callq 0x16990
testl %eax, %eax
js 0x595ee
movl $0x1, -0x1050(%rbx)
jmp 0x595fe
callq 0x16120
movl $0x19, (%rax)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/build/c/shell.c
// Function: getcols
static int getcols(void) {
#ifdef _WIN32
    CONSOLE_SCREEN_BUFFER_INFO csbi;
    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
    return (int)(csbi.srWindow.Right - csbi.srWindow.Left + 1);
#else
    struct winsize ws;
    if (ioctl(1, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0) {
        int start, cols;
        start = curpos();
        if (start == -1) goto failed;
        if (write_console("\x1b[999C", 6) != 6) goto failed;
        cols = curpos();
        if (cols == -1) goto failed;
        if (cols > start) {
            char seq[32];
            snprintf(seq, 32, "\x1b[%dD", cols - start);
            if (write_console(seq, strlen(seq)) == -1) {
                exit(1);
            }
        }
        return cols;
    } else {
        return ws.ws_col;
    }
failed:
    return 80;
#endif
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x8(%rsp), %rbx
movl $0x5413, %esi           # imm = 0x5413
movl $0x1, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x16410
cmpl $-0x1, %eax
sete %cl
movzwl 0x2(%rbx), %eax
testw %ax, %ax
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x596bf
callq 0x59d4d
movl $0x50, %ebp
cmpl $-0x1, %eax
je 0x596c2
movl %eax, %r14d
leaq 0x54d81(%rip), %rsi     # 0xae3db
movl $0x6, %edx
movl $0x1, %edi
callq 0x16250
cmpq $0x6, %rax
jne 0x596c2
callq 0x59d4d
cmpl $-0x1, %eax
je 0x596c2
movl %eax, %ebx
movl %eax, %ecx
subl %r14d, %ecx
jle 0x596bb
leaq 0x54d59(%rip), %rdx     # 0xae3e2
leaq 0x10(%rsp), %r14
movl $0x20, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x16390
movq %r14, %rdi
callq 0x16310
movl $0x1, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x16250
cmpq $-0x1, %rax
je 0x596cd
movl %ebx, %ebp
jmp 0x596c2
movzwl %ax, %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x1, %edi
callq 0x16aa0
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/build/c/shell.c
// Function: insert
static int insert(char c, int draw) {
    if (gbl_len < JANET_LINE_MAX - 1) {
        if (gbl_len == gbl_pos) {
            gbl_buf[gbl_pos++] = c;
            gbl_buf[++gbl_len] = '\0';
            if (draw) {
                if (gbl_plen + gbl_len < gbl_cols) {
                    /* Avoid a full update of the line in the
                     * trivial case. */
                    if (write_console(&c, 1) == -1) return -1;
                } else {
                    refresh();
                }
            }
        } else {
            memmove(gbl_buf + gbl_pos + 1, gbl_buf + gbl_pos, gbl_len - gbl_pos);
            gbl_buf[gbl_pos++] = c;
            gbl_buf[++gbl_len] = '\0';
            if (draw) refresh();
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movl %edi, %ebp
movb %bpl, 0xb(%rsp)
movq %fs:0x0, %rax
movslq -0x145c(%rax), %r15
cmpq $0x3fe, %r15            # imm = 0x3FE
jg 0x597c7
leaq -0x145c(%rax), %rsi
leaq -0x1010(%rax), %r12
movslq (%r12), %rbx
leaq -0x1450(%rax), %r13
cmpl %ebx, %r15d
jne 0x5977a
movl %ebx, %ecx
incl %ecx
movl %ecx, (%r12)
movb %bpl, (%r13,%rbx)
leaq 0x1(%r15), %rdx
movl %edx, (%rsi)
movb $0x0, 0x1(%r13,%r15)
testl %r14d, %r14d
je 0x597c7
addl -0x1aec(%rax), %edx
cmpl -0x1af0(%rax), %edx
jge 0x597c2
leaq 0xb(%rsp), %rsi
movl $0x1, %edx
movl $0x1, %edi
callq 0x16250
cmpq $-0x1, %rax
jne 0x597c7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x597c9
movq %rsi, 0x10(%rsp)
leaq (%rbx,%r13), %rsi
movl %r14d, 0xc(%rsp)
leaq (%rbx,%r13), %r14
incq %r14
movl %r15d, %eax
subl %ebx, %eax
movslq %eax, %rdx
movq %r14, %rdi
callq 0x16950
leal 0x1(%rbx), %eax
movl %eax, (%r12)
movb %bpl, -0x1(%r14)
leaq 0x1(%r15), %rax
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
movb $0x0, 0x1(%r13,%r15)
cmpl $0x0, 0xc(%rsp)
je 0x597c7
callq 0x597d8
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/build/c/shell.c
// Function: refresh
static void refresh(void) {
    char seq[64];
    JanetBuffer b;

    /* Keep cursor position on screen */
    char *_buf = gbl_buf;
    int _len = gbl_len;
    int _pos = gbl_pos;
    while ((gbl_plen + _pos) >= gbl_cols) {
        _buf++;
        _len--;
        _pos--;
    }
    while ((gbl_plen + _len) > gbl_cols) {
        _len--;
    }

    janet_buffer_init(&b, 0);
    /* Cursor to left edge, gbl_prompt and buffer */
    janet_buffer_push_u8(&b, '\r');
    janet_buffer_push_cstring(&b, gbl_prompt);
    janet_buffer_push_bytes(&b, (uint8_t *) _buf, _len);
    /* Erase to right */
    janet_buffer_push_cstring(&b, "\x1b[0K");
    /* Move cursor to original position. */
    snprintf(seq, 64, "\r\x1b[%dC", (int)(_pos + gbl_plen));
    janet_buffer_push_cstring(&b, seq);
    if (write_console((char *) b.data, b.count) == -1) {
        exit(1);
    }
    janet_buffer_deinit(&b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %fs:0x0, %rax
movq %rax, %r14
leaq -0x1450(%rax), %rbx
movl -0x145c(%rax), %ebp
movl -0x1010(%rax), %edx
leaq -0x1aec(%rax), %r13
movl (%r13), %ecx
movl -0x1af0(%rax), %eax
leal (%rcx,%rdx), %esi
cmpl %eax, %esi
jge 0x59825
movl %edx, %r15d
jmp 0x5983c
incq %rbx
decl %ebp
movl %edx, %r15d
decl %r15d
leal (%rcx,%rdx), %esi
decl %esi
movl %r15d, %edx
cmpl %eax, %esi
jge 0x59825
addl %ecx, %ebp
cmpl %ebp, %eax
cmovll %eax, %ebp
subl %ecx, %ebp
movq %rsp, %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x1c32d
movq %r12, %rdi
movl $0xd, %esi
callq 0x1c643
movq -0x1af8(%r14), %rsi
movq %r12, %rdi
callq 0x1c592
movq %r12, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1c5d5
leaq 0x54b71(%rip), %rsi     # 0xae3f3
movq %r12, %rdi
callq 0x1c592
addl (%r13), %r15d
leaq 0x54b63(%rip), %rdx     # 0xae3f8
leaq 0x20(%rsp), %rbx
movl $0x40, %esi
movq %rbx, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x16390
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1c592
movq 0x18(%r12), %rsi
movslq 0x10(%r12), %rdx
movl $0x1, %edi
callq 0x16250
cmpq $-0x1, %rax
je 0x598e8
movq %rsp, %rdi
callq 0x1c3e9
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0x16aa0
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/build/c/shell.c
// Function: clearlines
static void clearlines(void) {
    for (int i = 0; i < gbl_lines_below; i++) {
        fprintf(stderr, "\x1b[1B\x1b[999D\x1b[K");
    }
    if (gbl_lines_below) {
        fprintf(stderr, "\x1b[%dA\x1b[999D", gbl_lines_below);
        fflush(stderr);
        gbl_lines_below = 0;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %fs:0x0, %rax
leaq -0x100c(%rax), %rbx
movl (%rbx), %edi
testl %edi, %edi
jle 0x5993f
xorl %ebp, %ebp
movq 0x6e6d5(%rip), %r15     # 0xc7ff0
leaq 0x54add(%rip), %r14     # 0xae3ff
movq (%r15), %rcx
movl $0xd, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x16ac0
incl %ebp
movl (%rbx), %edi
cmpl %edi, %ebp
jl 0x59922
testl %edi, %edi
jne 0x5994e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rsi
callq 0x184b8
jmp 0x59943
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/build/c/shell.c
// Function: kdelete
static void kdelete(int draw) {
    if (gbl_pos != gbl_len) {
        memmove(gbl_buf + gbl_pos, gbl_buf + gbl_pos + 1, gbl_len - gbl_pos);
        gbl_buf[--gbl_len] = '\0';
        if (draw) refresh();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movq %fs:0x0, %rax
movslq -0x1010(%rax), %rdx
movslq -0x145c(%rax), %r15
cmpl %edx, %r15d
je 0x599d3
leaq -0x145c(%rax), %r12
movq %rax, %r14
leaq (%rax,%rdx), %rdi
addq $-0x1450, %rdi          # imm = 0xEBB0
leaq (%rax,%rdx), %rsi
addq $-0x144f, %rsi          # imm = 0xEBB1
movl %r15d, %eax
subl %edx, %eax
movslq %eax, %rdx
callq 0x16950
leaq -0x1(%r15), %rax
movl %eax, (%r12)
movb $0x0, -0x1451(%r14,%r15)
testl %ebx, %ebx
je 0x599d3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x597d8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/build/c/shell.c
// Function: historymove
static void historymove(int delta) {
    if (gbl_history_count > 1) {
        janet_free(gbl_history[gbl_historyi]);
        gbl_history[gbl_historyi] = sdup(gbl_buf);

        gbl_historyi += delta;
        if (gbl_historyi < 0) {
            gbl_historyi = 0;
        } else if (gbl_historyi >= gbl_history_count) {
            gbl_historyi = gbl_history_count - 1;
        }
        strncpy(gbl_buf, gbl_history[gbl_historyi], JANET_LINE_MAX - 1);
        gbl_pos = gbl_len = (int) strlen(gbl_buf);
        gbl_buf[gbl_len] = '\0';

        refresh();
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebp
movq %fs:0x0, %rax
cmpl $0x2, -0x1784(%rax)
jl 0x59a61
movq %rax, %rbx
movq %rax, %r15
movq %rax, %r12
leaq -0x1780(%rax), %rax
movq %rax, (%rsp)
leaq -0x1460(%rbx), %r13
movslq (%r13), %rax
movq -0x1780(%r12,%rax,8), %rdi
callq 0x160b0
leaq -0x1450(%rbx), %r14
movq %r14, %rdi
callq 0x59df2
movslq (%r13), %rcx
movq %rax, -0x1780(%r12,%rcx,8)
addl %ecx, %ebp
movl %ebp, (%r13)
js 0x59a70
leaq -0x1784(%r15), %rax
movl (%rax), %eax
cmpl %eax, %ebp
jl 0x59a76
decl %eax
jmp 0x59a72
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
movl %eax, (%r13)
movslq (%r13), %rax
movq (%rsp), %rcx
movq (%rcx,%rax,8), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
movq %r14, %rdi
callq 0x16150
movq %r14, %rdi
callq 0x16310
movq %rax, %rcx
movl %ecx, -0x145c(%rbx)
movl %ecx, -0x1010(%rbx)
movslq %ecx, %rax
movb $0x0, (%r14,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x597d8
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/build/c/shell.c
// Function: kbackspacew
static void kbackspacew(void) {
    while (gbl_pos && isspace(gbl_buf[gbl_pos - 1])) {
        kbackspace(0);
    }
    while (gbl_pos && !isspace(gbl_buf[gbl_pos - 1])) {
        kbackspace(0);
    }
    refresh();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %fs:0x0, %rax
movq %rax, 0x10(%rsp)
leaq -0x1010(%rax), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %ebp
testl %ebp, %ebp
je 0x59b64
callq 0x16c60
movq %rax, %r14
movq 0x10(%rsp), %rcx
leaq -0x1450(%rcx), %r12
leaq -0x145c(%rcx), %r13
movl (%r13), %ebx
movq (%r14), %rax
movslq %ebp, %r15
movsbq -0x1(%r12,%r15), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x59b64
testl %ebp, %ebp
jle 0x59b60
decq %r15
movl %ebp, %eax
leaq (%r12,%rax), %rsi
leaq (%r12,%rax), %rdi
decq %rdi
movl %ebx, %eax
subl %ebp, %eax
movslq %eax, %rdx
callq 0x16950
movq 0x8(%rsp), %rax
movl %r15d, (%rax)
movslq %ebx, %rax
leaq -0x1(%rax), %rbx
movl %ebx, (%r13)
movb $0x0, -0x1(%r12,%rax)
movl %r15d, %ebp
testl %ebp, %ebp
jne 0x59b11
movq 0x8(%rsp), %rax
movl (%rax), %ebp
testl %ebp, %ebp
je 0x59be9
callq 0x16c60
movq %rax, %r14
movq 0x10(%rsp), %rcx
leaq -0x1450(%rcx), %r12
leaq -0x145c(%rcx), %rbx
movl (%rbx), %r13d
movq 0x8(%rsp), %rax
movl (%rax), %eax
movq (%r14), %rcx
movslq %ebp, %r15
movsbq -0x1(%r12,%r15), %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x59be9
testl %ebp, %ebp
jle 0x59be3
decq %r15
movl %ebp, %eax
leaq (%r12,%rax), %rsi
leaq (%r12,%rax), %rdi
decq %rdi
movl %r13d, %eax
subl %ebp, %eax
movslq %eax, %rdx
callq 0x16950
movq 0x8(%rsp), %rax
movl %r15d, (%rax)
movslq %r13d, %rax
leaq -0x1(%rax), %r13
movl %r13d, (%rbx)
movb $0x0, -0x1(%r12,%rax)
movl %r15d, %eax
movl %eax, %ebp
testl %eax, %eax
jne 0x59b94
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x597d8
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/build/c/shell.c
// Function: krightw
static void krightw(void) {
    while (gbl_pos != gbl_len && isspace(gbl_buf[gbl_pos])) {
        gbl_pos++;
    }
    while (gbl_pos != gbl_len && !isspace(gbl_buf[gbl_pos])) {
        gbl_pos++;
    }
    refresh();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %fs:0x0, %rax
movq %rax, %rbx
leaq -0x1010(%rax), %r14
movl -0x145c(%rax), %r15d
movslq (%r14), %r12
cmpl %r15d, %r12d
je 0x59c62
callq 0x16c60
movq (%rax), %rcx
leaq (%rbx,%r12), %rax
addq $-0x1450, %rax          # imm = 0xEBB0
movl %r15d, %edx
negl %edx
leal 0x1(%r12), %esi
movsbq (%rax), %rdi
testb $0x20, 0x1(%rcx,%rdi,2)
je 0x59c62
movl %esi, (%r14)
incq %rax
leal (%rdx,%rsi), %edi
incl %edi
incl %esi
cmpl $0x1, %edi
jne 0x59c45
movslq (%r14), %r12
cmpl %r15d, %r12d
je 0x59ca2
callq 0x16c60
movq (%rax), %rcx
leaq (%rbx,%r12), %rax
addq $-0x1450, %rax          # imm = 0xEBB0
negl %r15d
leal 0x1(%r12), %edx
movsbq (%rax), %rsi
testb $0x20, 0x1(%rcx,%rsi,2)
jne 0x59ca2
movl %edx, (%r14)
incq %rax
leal (%r15,%rdx), %esi
incl %esi
incl %edx
cmpl $0x1, %esi
jne 0x59c84
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x597d8
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/build/c/shell.c
// Function: kleftw
static void kleftw(void) {
    while (gbl_pos > 0 && isspace(gbl_buf[gbl_pos - 1])) {
        gbl_pos--;
    }
    while (gbl_pos > 0 && !isspace(gbl_buf[gbl_pos - 1])) {
        gbl_pos--;
    }
    refresh();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %fs:0x0, %rax
movq %rax, %rbx
leaq -0x1010(%rax), %r14
movslq (%r14), %r15
testq %r15, %r15
jle 0x59d08
callq 0x16c60
movq (%rax), %rcx
leaq -0x1450(%rbx), %rax
movsbq -0x1(%rax,%r15), %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0x59d08
leaq -0x1(%r15), %rdx
decl %r15d
movl %r15d, (%r14)
leaq 0x1(%rdx), %rsi
movq %rdx, %r15
cmpq $0x1, %rsi
jg 0x59ce4
movslq (%r14), %r15
testq %r15, %r15
jle 0x59d43
callq 0x16c60
movq (%rax), %rcx
leaq -0x1450(%rbx), %rax
movsbq -0x1(%rax,%r15), %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x59d43
leaq -0x1(%r15), %rdx
decl %r15d
movl %r15d, (%r14)
leaq 0x1(%rdx), %rsi
movq %rdx, %r15
cmpq $0x1, %rsi
jg 0x59d1f
popq %rbx
popq %r14
popq %r15
jmp 0x597d8
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/build/c/shell.c
// Function: curpos
static int curpos(void) {
    char buf[32];
    int cols, rows;
    unsigned int i = 0;
    if (write_console("\x1b[6n", 4) != 4) return -1;
    while (i < sizeof(buf) - 1) {
        if (read_console(buf + i, 1) != 1) break;
        if (buf[i] == 'R') break;
        i++;
    }
    buf[i] = '\0';
    if (buf[0] != 27 || buf[1] != '[') return -1;
    if (sscanf(buf + 2, "%d;%d", &rows, &cols) != 2) return -1;
    return cols;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x5468d(%rip), %rsi     # 0xae3e8
movl $0x4, %edx
movl $0x1, %edi
callq 0x16250
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq $0x4, %rax
jne 0x59de8
xorl %r14d, %r14d
leaq (%rsp,%r14), %rsi
addq $0x10, %rsi
movl $0x1, %edx
xorl %edi, %edi
callq 0x16530
cmpq $0x1, %rax
jne 0x59da9
cmpb $0x52, 0x10(%rsp,%r14)
je 0x59da9
incq %r14
cmpq $0x1f, %r14
jne 0x59d78
movl $0x1f, %r14d
movb $0x0, 0x10(%rsp,%r14)
cmpb $0x1b, 0x10(%rsp)
jne 0x59de8
cmpb $0x5b, 0x11(%rsp)
jne 0x59de8
leaq 0x12(%rsp), %rdi
leaq 0x54624(%rip), %rsi     # 0xae3ed
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
xorl %eax, %eax
callq 0x167c0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x2, %eax
jne 0x59de8
movl 0x8(%rsp), %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/build/c/shell.c
// Function: sdup
static char *sdup(const char *s) {
    size_t len = strlen(s) + 1;
    char *mem = janet_malloc(len);
    if (!mem) {
        return NULL;
    }
    return memcpy(mem, s, len);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x16310
movq %rax, %r14
incq %r14
movq %r14, %rdi
callq 0x16780
testq %rax, %rax
je 0x59e26
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x16690
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/build/c/shell.c
// Function: get_symprefix
static JanetByteView get_symprefix(void) {
    /* Calculate current partial symbol. Maybe we could actually hook up the Janet
     * parser here...*/
    int i;
    JanetByteView ret;
    ret.len = 0;
    for (i = gbl_pos - 1; i >= 0; i--) {
        uint8_t c = (uint8_t) gbl_buf[i];
        if (!is_symbol_char_gen(c)) break;
        ret.len++;
    }
    /* Will be const for duration of match checking */
    ret.bytes = (const uint8_t *)(gbl_buf + i + 1);
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %fs:0x0, %rax
movq %rax, %rbx
movl -0x1010(%rax), %r14d
leaq -0x1450(%rax), %r12
movl %r14d, %r15d
sarl $0x1f, %r15d
andl %r14d, %r15d
decl %r15d
movq %r14, %r13
decq %r13
xorl %ebp, %ebp
testl %r14d, %r14d
jle 0x59f2b
movl %r13d, %eax
movzbl (%r12,%rax), %edi
callq 0x59e30
addl %eax, %ebp
decl %r14d
decq %r13
testl %eax, %eax
jne 0x59f0b
jmp 0x59f2e
movl %r15d, %r14d
movslq %r14d, %rcx
leaq (%rbx,%rcx), %rax
addq $-0x144f, %rax          # imm = 0xEBB1
movl %ebp, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/build/c/shell.c
// Function: check_match
static void check_match(JanetByteView src, const uint8_t *testsym, int32_t testlen) {
    JanetByteView test;
    test.bytes = testsym;
    test.len = testlen;
    if (src.len > test.len || strncmp((const char *) src.bytes, (const char *) test.bytes, src.len)) return;
    JanetByteView mm = test;
    for (int i = 0; i < gbl_match_count; i++) {
        if (compare_bytes(mm, gbl_matches[i]) < 0) {
            JanetByteView temp = mm;
            mm = gbl_matches[i];
            gbl_matches[i] = temp;
        }
    }
    if (gbl_match_count == JANET_MATCH_MAX) return;
    gbl_matches[gbl_match_count++] = mm;
}

// Assembly:
cmpl %ecx, %esi
jg 0x5a377
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movslq %esi, %rdx
movq %r14, %rsi
movl %ecx, %r12d
callq 0x16170
testl %eax, %eax
jne 0x5a369
movq %fs:0x0, %rax
movq %rax, 0x10(%rsp)
movslq -0x1008(%rax), %rcx
testq %rcx, %rcx
movq %rcx, 0x20(%rsp)
movq %rax, 0x18(%rsp)
jle 0x5a325
leaq -0x1000(%rax), %r13
shlq $0x4, %rcx
movq %rcx, 0x28(%rsp)
xorl %r15d, %r15d
movq %r14, %rbp
movq (%r13,%r15), %rsi
movl 0x8(%r13,%r15), %ebx
xorl %r14d, %r14d
cmpl %ebx, %r12d
movl %ebx, %eax
cmovll %r12d, %eax
movslq %eax, %rdx
setl %r14b
movq %rbp, %rdi
movq %rsi, 0x30(%rsp)
callq 0x16170
xorl %ecx, %ecx
testl %eax, %eax
sets %cl
cmovnel %ecx, %r14d
cmpb $0x1, %r14b
jne 0x5a312
movl 0xc(%r13,%r15), %eax
movq %rbp, (%r13,%r15)
movl %r12d, 0x8(%r13,%r15)
movl 0xc(%rsp), %ecx
movl %ecx, 0xc(%r13,%r15)
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %r14
movq %r14, %rbp
movl %ebx, %r12d
jmp 0x5a318
movl %r12d, %ebx
movq %rbp, %r14
addq $0x10, %r15
cmpq %r15, 0x28(%rsp)
jne 0x5a2ae
jmp 0x5a328
movl %r12d, %ebx
movq 0x20(%rsp), %rdx
cmpl $0x100, %edx            # imm = 0x100
je 0x5a369
movq 0x10(%rsp), %rax
leaq -0x1008(%rax), %rax
leal 0x1(%rdx), %ecx
movl %ecx, (%rax)
shlq $0x4, %rdx
movq 0x18(%rsp), %rax
movq %r14, -0x1000(%rax,%rdx)
movl %ebx, -0xff8(%rax,%rdx)
movl 0xc(%rsp), %ecx
movl %ecx, -0xff4(%rax,%rdx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O1/sos22[P]unexec/tests/smoke.c
// Function: main
int main(int argc, char *argv[]) {
    if (argc != 2) errx(1, "need a single argument, the thing to unexec to");
    int r = unexec(argv[1], NULL);
    if (r == 0) printf("restored\n");
    else if (r == 1) printf("unexeced\n");
    else err(1, "unexec");
    return 0; }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x2, %edi
jne 0x11a2
movq 0x8(%rsi), %rdi
xorl %esi, %esi
callq 0x1060
testl %eax, %eax
je 0x1192
cmpl $0x1, %eax
jne 0x11b5
leaq 0xeaa(%rip), %rdi       # 0x203a
jmp 0x1199
leaq 0xeaa(%rip), %rdi       # 0x2043
callq 0x1030
xorl %eax, %eax
popq %rbp
retq
leaq 0xe5b(%rip), %rsi       # 0x2004
movl $0x1, %edi
xorl %eax, %eax
callq 0x1040
leaq 0xe77(%rip), %rsi       # 0x2033
movl $0x1, %edi
xorl %eax, %eax
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/algorithm-archivists[P]GathVL/vis_test.cpp
// Function: main
int main() {
    camera cam(vec{1280, 720});
    scene world = scene({1280, 720}, {0, 0, 0, 1});

    cam.add_encoder<video_encoder>("/tmp/video.mp4", cam.size, 50);

    first_scene(cam, world);

    second_scene(cam, world);

    cam.clear_encoders();

    return 0;
}

// Assembly:
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
leaq 0x50(%rsp), %rdi
movsd 0x1cbc6(%rip), %xmm2    # 0x23040
movsd 0x1cbc6(%rip), %xmm3    # 0x23048
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x7ba2
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x48(%rsp)
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0xa8(%rsp), %rdi
movsd 0x1cb70(%rip), %xmm0    # 0x23040
movsd 0x1cb70(%rip), %xmm1    # 0x23048
callq 0x7d90
leaq 0x2c(%rsp), %rcx
movl $0x32, (%rcx)
leaq 0x1cb6d(%rip), %rsi     # 0x2305c
leaq 0x50(%rsp), %rdi
movq %rdi, %rdx
callq 0x67a8
leaq 0x50(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x5b1c
leaq 0x50(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x5f72
leaq 0x50(%rsp), %rdi
callq 0x7b56
movq 0x108(%rsp), %rdi
testq %rdi, %rdi
je 0x653e
callq *0x100(%rsp)
movq $0x0, 0x108(%rsp)
movq 0xf8(%rsp), %rdi
testq %rdi, %rdi
je 0x655e
callq *0xf0(%rsp)
leaq 0xd8(%rsp), %rdi
movq $0x0, 0x20(%rdi)
callq 0x68fc
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x6587
callq *0x98(%rsp)
movq $0x0, 0xa0(%rsp)
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x65a7
callq *0x88(%rsp)
leaq 0x70(%rsp), %rdi
movq $0x0, 0x20(%rdi)
callq 0x6986
xorl %eax, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
retq
jmp 0x65ca
jmp 0x65ca
jmp 0x65ca
movq %rax, %rdi
callq 0x68f1
jmp 0x65d9
movq %rax, %rbx
jmp 0x65e9
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x67fa
leaq 0x50(%rsp), %rdi
callq 0x683e
movq %rbx, %rdi
callq 0x5510
nop
// File: /workspace/github_c_makefile_star2_O1/algorithm-archivists[P]GathVL/src/camera.cpp
// Function: camera::capture(scene&)
void camera::capture(scene &s) {
    s.draw();
    cairo_set_source_surface(context.get(), s.surface.get(),
                             static_cast<int>(location.x),
                             static_cast<int>(location.y));
    cairo_paint(context.get());
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7eba
movq 0x50(%r14), %rdi
movq 0x50(%rbx), %rsi
movsd 0x10(%r14), %xmm0
movsd 0x18(%r14), %xmm1
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
cvttpd2dq %xmm1, %xmm1
cvtdq2pd %xmm1, %xmm1
callq 0x5820
movq 0x50(%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x51a0
nop