LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: spec_tag1
static void spec_tag1(Builder *b, int32_t argc, const Janet *argv, uint32_t op) {
    peg_arity(b, argc, 0, 1);
    Reserve r = reserve(b, 2);
    uint32_t tag = (argc) ? emit_tag(b, argv[0]) : 0;
    (void) argv;
    emit_1(r, op, tag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x59770
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x57ec0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x5974a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x59800
movl %eax, -0x38(%rbp)
jmp 0x59751
xorl %eax, %eax
movl %eax, -0x38(%rbp)
jmp 0x59751
movl -0x38(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x1c(%rbp), %edx
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x57fb0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: peg_arity
static void peg_arity(Builder *b, int32_t arity, int32_t min, int32_t max) {
    if (min >= 0 && arity < min)
        peg_panicf(b, "arity mismatch, expected at least %d, got %d", min, arity);
    if (max >= 0 && arity > max)
        peg_panicf(b, "arity mismatch, expected at most %d, got %d", max, arity);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x597bb
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x597bb
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0x27f59(%rip), %rdi     # 0x81701
movb $0x0, %al
callq 0x5bdd0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x57e80
cmpl $0x0, -0x14(%rbp)
jl 0x597f1
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x597f1
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0x27f56(%rip), %rdi     # 0x81734
movb $0x0, %al
callq 0x5bdd0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x57e80
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: emit_tag
static uint32_t emit_tag(Builder *b, Janet t) {
    if (!janet_checktype(t, JANET_KEYWORD))
        peg_panicf(b, "expected keyword for capture tag, got %v", t);
    Janet check = janet_table_get(b->tags, t);
    if (janet_checktype(check, JANET_NIL)) {
        uint32_t tag = b->nexttag++;
        if (tag > 255) {
            peg_panic(b, "too many tags - up to 255 tags are supported per peg");
        }
        Janet val = janet_wrap_number(tag);
        janet_table_put(b->tags, t, val);
        return tag;
    } else {
        return (uint32_t) janet_unwrap_number(check);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0x59818
jmp 0x5983e
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x5982a
jmp 0x59881
movq -0x10(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x59881
jmp 0x5985b
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x10(%rbp), %rax
movabsq $-0x5000000000000, %rcx # imm = 0xFFFB000000000000
cmpq %rcx, %rax
je 0x59881
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x3bc02(%rip), %rdi     # 0x95470
movb $0x0, %al
callq 0x5bdd0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x57e80
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x69420
movq %rax, -0x20(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0x5989e
jmp 0x598c4
movsd -0x20(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x598b0
jmp 0x598e1
movq -0x20(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x598e1
jmp 0x5993a
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x20(%rbp), %rax
movabsq $-0x7800000000000, %rcx # imm = 0xFFF8800000000000
cmpq %rcx, %rax
jne 0x5993a
movq -0x18(%rbp), %rcx
movl 0x34(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x34(%rcx)
movl %eax, -0x24(%rbp)
cmpl $0xff, -0x24(%rbp)
jbe 0x5990c
movq -0x18(%rbp), %rdi
leaq 0x3bb92(%rip), %rsi     # 0x95499
callq 0x57e80
movl -0x24(%rbp), %eax
cvtsi2sd %rax, %xmm0
callq 0x7b820
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x697e0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x59943
cvttsd2si -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: spec_cap1
static void spec_cap1(Builder *b, int32_t argc, const Janet *argv, uint32_t op) {
    peg_arity(b, argc, 1, 2);
    Reserve r = reserve(b, 3);
    uint32_t tag = (argc == 2) ? emit_tag(b, argv[1]) : 0;
    uint32_t rule = peg_compile1(b, argv[0]);
    emit_2(r, op, rule, tag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x59770
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x57ec0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x599ae
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x59800
movl %eax, -0x3c(%rbp)
jmp 0x599b5
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x599b5
movl -0x3c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x571d0
movl %eax, -0x38(%rbp)
movl -0x1c(%rbp), %edx
movl -0x38(%rbp), %ecx
movl -0x34(%rbp), %r8d
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x599f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: spec_repeater
static void spec_repeater(Builder *b, int32_t argc, const Janet *argv, int32_t min) {
    peg_fixarity(b, argc, 1);
    Reserve r = reserve(b, 4);
    uint32_t subrule = peg_compile1(b, argv[0]);
    emit_3(r, RULE_BETWEEN, min, UINT32_MAX, subrule);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0x58360
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x57ec0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x571d0
movl %eax, -0x34(%rbp)
movl -0x1c(%rbp), %ecx
movl -0x34(%rbp), %r9d
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0xb, %edx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x58420
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: spec_branch
static void spec_branch(Builder *b, int32_t argc, const Janet *argv, uint32_t rule) {
    peg_fixarity(b, argc, 2);
    Reserve r = reserve(b, 3);
    uint32_t rule_a = peg_compile1(b, argv[0]);
    uint32_t rule_b = peg_compile1(b, argv[1]);
    emit_2(r, rule, rule_a, rule_b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x2, %edx
callq 0x58360
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x57ec0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x571d0
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x571d0
movl %eax, -0x38(%rbp)
movl -0x1c(%rbp), %edx
movl -0x34(%rbp), %ecx
movl -0x38(%rbp), %r8d
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x599f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: spec_readint
static void spec_readint(Builder *b, int32_t argc, const Janet *argv, uint32_t mask) {
    peg_arity(b, argc, 1, 2);
    Reserve r = reserve(b, 3);
    uint32_t tag = (argc == 2) ? emit_tag(b, argv[1]) : 0;
    int32_t width = peg_getnat(b, argv[0]);
    if ((width < 0) || (width > JANET_MAX_READINT_WIDTH)) {
        peg_panicf(b, "width must be between 0 and %d, got %d", JANET_MAX_READINT_WIDTH, width);
    }
    emit_2(r, RULE_READINT, mask | ((uint32_t) width), tag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x59770
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x57ec0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x59e6e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x59800
movl %eax, -0x3c(%rbp)
jmp 0x59e75
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x59e75
movl -0x3c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x583c0
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jl 0x59e9a
cmpl $0x8, -0x38(%rbp)
jle 0x59ec4
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x38(%rbp), %edx
leaq 0x3b649(%rip), %rdi     # 0x954f5
movl $0x8, %esi
movb $0x0, %al
callq 0x5bdd0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x57e80
movl -0x1c(%rbp), %ecx
orl -0x38(%rbp), %ecx
movl -0x34(%rbp), %r8d
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1b, %edx
callq 0x599f0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: peg_getrange
static const uint8_t *peg_getrange(Builder *b, Janet x) {
    if (!janet_checktype(x, JANET_STRING))
        peg_panic(b, "expected string for character range");
    const uint8_t *str = janet_unwrap_string(x);
    if (janet_string_length(str) != 2)
        peg_panicf(b, "expected string to have length 2, got %v", x);
    if (str[1] < str[0])
        peg_panicf(b, "range %v is empty", x);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0x59f08
jmp 0x59f2e
movsd -0x8(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x59f1a
jmp 0x59f5b
movq -0x8(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x59f5b
jmp 0x59f4b
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x8(%rbp), %rax
movabsq $-0x6000000000000, %rcx # imm = 0xFFFA000000000000
cmpq %rcx, %rax
je 0x59f5b
movq -0x10(%rbp), %rdi
leaq 0x3b5f0(%rip), %rsi     # 0x95546
callq 0x57e80
movq -0x8(%rbp), %rdi
callq 0x7b260
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, -0x8(%rax)
je 0x59f98
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x3b5e5(%rip), %rdi     # 0x9556a
movb $0x0, %al
callq 0x5bdd0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x57e80
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x59fd1
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x3b5d5(%rip), %rdi     # 0x95593
movb $0x0, %al
callq 0x5bdd0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x57e80
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: peg_getset
static const uint8_t *peg_getset(Builder *b, Janet x) {
    if (!janet_checktype(x, JANET_STRING))
        peg_panic(b, "expected string for character set");
    const uint8_t *str = janet_unwrap_string(x);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0x5a038
jmp 0x5a05e
movsd -0x8(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x5a04a
jmp 0x5a08b
movq -0x8(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x5a08b
jmp 0x5a07b
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x8(%rbp), %rax
movabsq $-0x6000000000000, %rcx # imm = 0xFFFA000000000000
cmpq %rcx, %rax
je 0x5a08b
movq -0x10(%rbp), %rdi
leaq 0x3b51f(%rip), %rsi     # 0x955a5
callq 0x57e80
movq -0x8(%rbp), %rdi
callq 0x7b260
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: cap_save
static CapState cap_save(PegState *s) {
    CapState cs;
    cs.scratch = s->scratch->count;
    cs.cap = s->captures->count;
    cs.tcap = s->tagged_captures->count;
    return cs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x4(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl -0x20(%rbp), %edx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: cap_load
static void cap_load(PegState *s, CapState cs) {
    s->scratch->count = cs.scratch;
    s->captures->count = cs.cap;
    s->tags->count = cs.tcap;
    s->tagged_captures->count = cs.tcap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, -0x1c(%rbp)
movl %edx, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rdi, -0x28(%rbp)
movl -0x4(%rbp), %ecx
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movl %ecx, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movl %ecx, 0x10(%rax)
movl -0x8(%rbp), %ecx
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movl %ecx, 0x10(%rax)
movl -0x8(%rbp), %ecx
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl %ecx, 0x10(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: pushcap
static void pushcap(PegState *s, Janet capture, uint32_t tag) {
    if (s->mode == PEG_MODE_ACCUMULATE) {
        janet_to_string_b(s->scratch, capture);
    }
    if (s->mode == PEG_MODE_NORMAL) {
        janet_array_push(s->captures, capture);
    }
    if (s->has_backref) {
        janet_array_push(s->tagged_captures, capture);
        janet_buffer_push_u8(s->tags, tag);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x68(%rax)
jne 0x5a18e
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x5a400
movq -0x10(%rbp), %rax
cmpl $0x0, 0x68(%rax)
jne 0x5a1a9
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x13510
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0x5a1d7
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x13510
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movl -0x14(%rbp), %eax
movzbl %al, %esi
callq 0x18820
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/pp.c
// Function: number_to_string_b
static void number_to_string_b(JanetBuffer *buffer, double x) {
    janet_buffer_ensure(buffer, buffer->count + BUFSIZE, 2);
    const char *fmt = (x == floor(x) &&
                       x <= JANET_INTMAX_DOUBLE &&
                       x >= JANET_INTMIN_DOUBLE) ? "%.0f" : ("%." STR(DBL_DIG) "g");
    int count;
    if (x == 0.0) {
        /* Prevent printing of '-0' */
        count = 1;
        buffer->data[buffer->count] = '0';
    } else {
        count = snprintf((char *) buffer->data + buffer->count, BUFSIZE, fmt, x);
    }
    buffer->count += count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
addl $0x40, %esi
movl $0x2, %edx
callq 0x184c0
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x12a00
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, -0x1d(%rbp)
jne 0x5a76d
jp 0x5a76d
xorl %eax, %eax
movsd 0x3067c(%rip), %xmm0    # 0x8adc8
ucomisd -0x10(%rbp), %xmm0
movb %al, -0x1d(%rbp)
jb 0x5a76d
movsd -0x10(%rbp), %xmm0
movsd 0x3065d(%rip), %xmm1    # 0x8adc0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %dl
leaq 0x3b35d(%rip), %rax     # 0x95ad4
leaq 0x3b351(%rip), %rcx     # 0x95acf
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5a7b6
jp 0x5a7b6
movl $0x1, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x10(%rcx), %rcx
movb $0x30, (%rax,%rcx)
jmp 0x5a7e1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rdx
movsd -0x10(%rbp), %xmm0
movl $0x40, %esi
movb $0x1, %al
callq 0x12390
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/pp.c
// Function: janet_description_b
void janet_description_b(JanetBuffer *buffer, Janet x) {
    switch (janet_type(x)) {
        default:
            break;
        case JANET_NIL:
            janet_buffer_push_cstring(buffer, "nil");
            return;
        case JANET_KEYWORD:
            janet_buffer_push_u8(buffer, ':');
            break;
        case JANET_STRING:
            janet_escape_string_b(buffer, janet_unwrap_string(x));
            return;
        case JANET_BUFFER: {
            JanetBuffer *b = janet_unwrap_buffer(x);
            janet_escape_buffer_b(buffer, b);
            return;
        }
        case JANET_ABSTRACT: {
            JanetAbstract p = janet_unwrap_abstract(x);
            const JanetAbstractType *t = janet_abstract_type(p);
            if (t->tostring != NULL) {
                janet_buffer_push_cstring(buffer, "<");
                janet_buffer_push_cstring(buffer, t->name);
                janet_buffer_push_cstring(buffer, " ");
                t->tostring(p, buffer);
                janet_buffer_push_cstring(buffer, ">");
            } else {
                string_description_b(buffer, t->name, p);
            }
            return;
        }
    }
    janet_to_string_b(buffer, x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x5a9b2
jmp 0x5a9c3
movq -0x8(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
movl %eax, -0x2c(%rbp)
jmp 0x5a9ca
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5a9ca
movl -0x2c(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0xd, %eax
ja 0x5a9ee
movq -0x38(%rbp), %rax
leaq 0x3ac73(%rip), %rcx     # 0x95658
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x5aaea
movq -0x10(%rbp), %rdi
leaq 0x31d53(%rip), %rsi     # 0x8c751
callq 0x18750
jmp 0x5aaf7
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
callq 0x18820
jmp 0x5aaea
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7b260
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x5ab00
jmp 0x5aaf7
movq -0x8(%rbp), %rdi
callq 0x7b260
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5ab30
jmp 0x5aaf7
movq -0x8(%rbp), %rdi
callq 0x7b260
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x5aad4
movq -0x10(%rbp), %rdi
leaq 0x3e5d2(%rip), %rsi     # 0x9905d
callq 0x18750
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x18750
movq -0x10(%rbp), %rdi
leaq 0x39e60(%rip), %rsi     # 0x9490b
callq 0x18750
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq -0x10(%rbp), %rdi
leaq 0x3a907(%rip), %rsi     # 0x953d4
callq 0x18750
jmp 0x5aae8
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x5a800
jmp 0x5aaf7
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x5a400
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/pp.c
// Function: janet_escape_buffer_b
static void janet_escape_buffer_b(JanetBuffer *buffer, JanetBuffer *bx) {
    if (bx == buffer) {
        /* Ensures buffer won't resize while escaping */
        janet_buffer_ensure(bx, bx->count + 5 * bx->count + 3, 1);
    }
    janet_buffer_push_u8(buffer, '@');
    janet_escape_string_impl(buffer, bx->data, bx->count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x5ab6c
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
imull $0x5, 0x10(%rax), %eax
addl %eax, %esi
addl $0x3, %esi
movl $0x1, %edx
callq 0x184c0
movq -0x8(%rbp), %rdi
movl $0x40, %esi
callq 0x18820
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x5c580
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/pp.c
// Function: janet_description
const uint8_t *janet_description(Janet x) {
    JanetBuffer b;
    janet_buffer_init(&b, 10);
    janet_description_b(&b, x);
    const uint8_t *ret = janet_string(b.data, b.count);
    janet_buffer_deinit(&b);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
movl $0xa, %esi
callq 0x182e0
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x5a990
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x64880
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x18460
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/pp.c
// Function: janet_to_string
const uint8_t *janet_to_string(Janet x) {
    switch (janet_type(x)) {
        default: {
            JanetBuffer b;
            janet_buffer_init(&b, 10);
            janet_to_string_b(&b, x);
            const uint8_t *ret = janet_string(b.data, b.count);
            janet_buffer_deinit(&b);
            return ret;
        }
        case JANET_BUFFER:
            return janet_string(janet_unwrap_buffer(x)->data, janet_unwrap_buffer(x)->count);
        case JANET_STRING:
        case JANET_SYMBOL:
        case JANET_KEYWORD:
            return janet_unwrap_string(x);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x5ac0e
jmp 0x5ac1f
movq -0x10(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
movl %eax, -0x3c(%rbp)
jmp 0x5ac26
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5ac26
movl -0x3c(%rbp), %eax
movl %eax, -0x40(%rbp)
addl $-0x4, %eax
subl $0x3, %eax
jb 0x5acaa
jmp 0x5ac36
movl -0x40(%rbp), %eax
subl $0xb, %eax
je 0x5ac7e
jmp 0x5ac40
leaq -0x30(%rbp), %rdi
movl $0xa, %esi
callq 0x182e0
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5a400
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x64880
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x18460
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5acb7
movq -0x10(%rbp), %rdi
callq 0x7b260
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7b260
movq -0x48(%rbp), %rdi
movl 0x10(%rax), %esi
callq 0x64880
movq %rax, -0x8(%rbp)
jmp 0x5acb7
movq -0x10(%rbp), %rdi
callq 0x7b260
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/pp.c
// Function: janet_pretty_
static JanetBuffer *janet_pretty_(JanetBuffer *buffer, int depth, int flags, Janet x, int32_t startlen) {
    struct pretty S;
    if (NULL == buffer) {
        buffer = janet_buffer(0);
    }
    S.buffer = buffer;
    S.depth = depth;
    S.indent = 0;
    S.flags = flags;
    S.bufstartlen = startlen;
    S.keysort_capacity = 0;
    S.keysort_buffer = NULL;
    S.keysort_start = 0;
    janet_table_init(&S.seen, 10);
    janet_pretty_one(&S, x, 0);
    janet_table_deinit(&S.seen);
    return S.buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rcx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x5ad70
xorl %edi, %edi
callq 0x18490
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x70(%rbp)
movl $0x0, -0x6c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x68(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x64(%rbp)
movl $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movl $0x0, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
addq $0x28, %rdi
movl $0xa, %esi
callq 0x69160
movq -0x8(%rbp), %rsi
leaq -0x78(%rbp), %rdi
xorl %edx, %edx
callq 0x5c7a0
leaq -0x78(%rbp), %rdi
addq $0x28, %rdi
callq 0x692b0
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/pp.c
// Function: janet_jdn_
static JanetBuffer *janet_jdn_(JanetBuffer *buffer, int depth, Janet x, int32_t startlen) {
    struct pretty S;
    if (NULL == buffer) {
        buffer = janet_buffer(0);
    }
    S.buffer = buffer;
    S.depth = depth;
    S.indent = 0;
    S.flags = 0;
    S.bufstartlen = startlen;
    S.keysort_capacity = 0;
    S.keysort_buffer = NULL;
    S.keysort_start = 0;
    janet_table_init(&S.seen, 10);
    int res = print_jdn_one(&S, x, depth);
    janet_table_deinit(&S.seen);
    if (res) {
        janet_panic("could not print to jdn format");
    }
    return S.buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x5ae7c
xorl %edi, %edi
callq 0x18490
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x68(%rbp)
movl $0x0, -0x64(%rbp)
movl $0x0, -0x60(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movl $0x0, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
addq $0x28, %rdi
movl $0xa, %esi
callq 0x69160
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x5d5b0
movl %eax, -0x74(%rbp)
leaq -0x70(%rbp), %rdi
addq $0x28, %rdi
callq 0x692b0
cmpl $0x0, -0x74(%rbp)
je 0x5aef8
leaq 0x3ac4d(%rip), %rdi     # 0x95b40
callq 0x1ad60
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/pp.c
// Function: typestr
static const char *typestr(Janet x) {
    JanetType t = janet_type(x);
    return (t == JANET_ABSTRACT)
           ? janet_abstract_type(janet_unwrap_abstract(x))->name
           : janet_type_names[t];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x5bcde
jmp 0x5bcef
movq -0x8(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
movl %eax, -0x10(%rbp)
jmp 0x5bcf6
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0x5bcf6
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0xe, -0xc(%rbp)
jne 0x5bd18
movq -0x8(%rbp), %rdi
callq 0x7b260
movq -0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5bd2c
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x53f0c(%rip), %rax     # 0xafc30
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/pp.c
// Function: pushtypes
static void pushtypes(JanetBuffer *buffer, int types) {
    int first = 1;
    int i = 0;
    while (types) {
        if (1 & types) {
            if (first) {
                first = 0;
            } else {
                janet_buffer_push_cstring(buffer, (types == 1) ? " or " : ", ");
            }
            janet_buffer_push_cstring(buffer, janet_type_names[i]);
        }
        i++;
        types >>= 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x5bdc9
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5bdb6
cmpl $0x0, -0x10(%rbp)
je 0x5bd7d
movl $0x0, -0x10(%rbp)
jmp 0x5bd9e
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %ecx
leaq 0x38b7f(%rip), %rsi     # 0x9490a
leaq 0x39e45(%rip), %rax     # 0x95bd7
cmpl $0x1, %ecx
cmoveq %rax, %rsi
callq 0x18750
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x53e83(%rip), %rax     # 0xafc30
movq (%rax,%rcx,8), %rsi
callq 0x18750
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
sarl %eax
movl %eax, -0xc(%rbp)
jmp 0x5bd5d
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/pp.c
// Function: janet_formatc
const uint8_t *janet_formatc(const char *format, ...) {
    va_list args;
    const uint8_t *ret;
    JanetBuffer buffer;
    int32_t len = 0;

    /* Calculate length, init buffer and args */
    while (format[len]) len++;
    janet_buffer_init(&buffer, len);
    va_start(args, format);

    /* Run format */
    janet_formatbv(&buffer, format, args);

    /* Iterate length */
    va_end(args);

    ret = janet_string(buffer.data, buffer.count);
    janet_buffer_deinit(&buffer);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x5be0e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rsi, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x4c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x5be55
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x5be3c
movl -0x4c(%rbp), %esi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x182e0
movq -0x108(%rbp), %rdi
leaq -0x100(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x5af10
movq -0x30(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x64880
movq -0x108(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x18460
movq -0x28(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/pp.c
// Function: janet_formatb
JanetBuffer *janet_formatb(JanetBuffer *buffer, const char *format, ...) {
    va_list args;
    va_start(args, format);
    janet_formatbv(buffer, format, args);
    va_end(args);
    return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x5bf08
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x5af10
movq -0x8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/pp.c
// Function: integer_to_string_b
static void integer_to_string_b(JanetBuffer *buffer, int32_t x) {
    janet_buffer_extra(buffer, BUFSIZE);
    uint8_t *buf = buffer->data + buffer->count;
    int32_t neg = 0;
    int32_t len = 0;
    if (x == 0) {
        buf[0] = '0';
        buffer->count++;
        return;
    }
    if (x > 0) {
        x = -x;
    } else {
        neg = 1;
        *buf++ = '-';
    }
    len = count_dig10(x);
    buf += len;
    while (x) {
        uint8_t digit = (uint8_t) - (x % 10);
        *(--buf) = '0' + digit;
        x /= 10;
    }
    buffer->count += len + neg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x40, %esi
callq 0x18650
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x10(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x5d411
movq -0x18(%rbp), %rax
movb $0x30, (%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x5d4a9
cmpl $0x0, -0xc(%rbp)
jle 0x5d421
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x5d43a
movl $0x1, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x2d, (%rax)
movl -0xc(%rbp), %edi
callq 0x5d530
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x5d499
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
xorl %eax, %eax
subl %edx, %eax
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
addl $0x30, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, -0x1(%rax)
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
jmp 0x5d456
movl -0x20(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/pp.c
// Function: print_newline
static void print_newline(struct pretty *S, int just_a_space) {
    int i;
    if (just_a_space || (S->flags & JANET_PRETTY_ONELINE)) {
        janet_buffer_push_u8(S->buffer, ' ');
        return;
    }
    janet_buffer_push_u8(S->buffer, '\n');
    for (i = 0; i < S->indent; i++) {
        janet_buffer_push_u8(S->buffer, ' ');
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x5d4d4
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x5d4e7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x20, %esi
callq 0x18820
jmp 0x5d527
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0xa, %esi
callq 0x18820
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x5d527
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x20, %esi
callq 0x18820
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5d4ff
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/pp.c
// Function: count_dig10
static int count_dig10(int32_t x) {
    int result = 1;
    for (;;) {
        if (x > -10) return result;
        if (x > -100) return result + 1;
        if (x > -1000) return result + 2;
        if (x > -10000) return result + 3;
        x /= 10000;
        result += 4;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
cmpl $-0xa, -0x8(%rbp)
jle 0x5d54c
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5d59e
cmpl $-0x64, -0x8(%rbp)
jle 0x5d55d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x5d59e
cmpl $0xfffffc18, -0x8(%rbp) # imm = 0xFFFFFC18
jle 0x5d571
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x4(%rbp)
jmp 0x5d59e
cmpl $0xffffd8f0, -0x8(%rbp) # imm = 0xFFFFD8F0
jle 0x5d585
movl -0xc(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x4(%rbp)
jmp 0x5d59e
movl -0x8(%rbp), %eax
movl $0x2710, %ecx           # imm = 0x2710
cltd
idivl %ecx
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
jmp 0x5d53e
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/pp.c
// Function: contains_bad_chars
static int contains_bad_chars(const uint8_t *sym, int issym) {
    int32_t len = janet_string_length(sym);
    if (len && issym && sym[0] >= '0' && sym[0] <= '9') return 1;
    if (!janet_valid_utf8(sym, len)) return 1;
    for (int32_t i = 0; i < len; i++) {
        if (!janet_is_symbol_char(sym[i])) return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl -0x8(%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x5dc66
cmpl $0x0, -0x14(%rbp)
je 0x5dc66
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jl 0x5dc66
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x39, %eax
jg 0x5dc66
movl $0x1, -0x4(%rbp)
jmp 0x5dcc2
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x4f7f0
cmpl $0x0, %eax
jne 0x5dc80
movl $0x1, -0x4(%rbp)
jmp 0x5dcc2
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x5dcbb
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x4f7b0
cmpl $0x0, %eax
jne 0x5dcae
movl $0x1, -0x4(%rbp)
jmp 0x5dcc2
jmp 0x5dcb0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5dc87
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/pp.c
// Function: get_fmt_mapping
static const char *get_fmt_mapping(char c) {
    for (size_t i = 0; i < (sizeof(format_mappings) / sizeof(struct FmtMapping)); i++) {
        if (format_mappings[i].c == c)
            return format_mappings[i].mapping;
    }
    janet_assert(0, "bad format mapping");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x8, -0x18(%rbp)
jae 0x5dd36
movq -0x18(%rbp), %rcx
leaq 0x51658(%rip), %rax     # 0xaf350
shlq $0x4, %rcx
addq %rcx, %rax
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5dd26
movq -0x18(%rbp), %rcx
leaq 0x5163b(%rip), %rax     # 0xaf350
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5dd6a
jmp 0x5dd28
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5dce6
jmp 0x5dd38
jmp 0x5dd3a
movq 0x522af(%rip), %rax     # 0xafff0
movq (%rax), %rdi
leaq 0x232c9(%rip), %rsi     # 0x81014
movl $0x31d, %edx            # imm = 0x31D
leaq 0x37dbd(%rip), %rcx     # 0x95b14
leaq 0x37e5d(%rip), %r8      # 0x95bbb
movb $0x0, %al
callq 0x125f0
callq 0x12100
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/regalloc.c
// Function: janetc_regalloc_init
void janetc_regalloc_init(JanetcRegisterAllocator *ra) {
    ra->chunks = NULL;
    ra->count = 0;
    ra->capacity = 0;
    ra->max = 0;
    ra->regtemps = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/regalloc.c
// Function: janetc_regalloc_clone
void janetc_regalloc_clone(JanetcRegisterAllocator *dest, JanetcRegisterAllocator *src) {
    size_t size;
    dest->count = src->count;
    dest->capacity = src->capacity;
    dest->max = src->max;
    size = sizeof(uint32_t) * (size_t) dest->capacity;
    dest->regtemps = 0;
    if (size) {
        dest->chunks = janet_malloc(size);
        if (!dest->chunks) {
            JANET_OUT_OF_MEMORY;
        }
        memcpy(dest->chunks, src->chunks, size);
    } else {
        dest->chunks = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rax
shlq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x5deb2
movq -0x18(%rbp), %rdi
callq 0x12770
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5de99
jmp 0x5de6b
movq 0x5217e(%rip), %rax     # 0xafff0
movq (%rax), %rdi
leaq 0x20188(%rip), %rsi     # 0x7e004
leaq 0x37d59(%rip), %rdx     # 0x95bdc
movl $0x4d, %ecx
movb $0x0, %al
callq 0x125f0
movl $0x1, %edi
callq 0x12a70
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x12680
jmp 0x5debd
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/regalloc.c
// Function: janetc_regalloc_touch
void janetc_regalloc_touch(JanetcRegisterAllocator *ra, int32_t reg) {
    int32_t chunk = reg >> 5;
    int32_t bit = reg & 0x1F;
    while (chunk >= ra->count) pushchunk(ra);
    ra->chunks[chunk] |= ithbit(bit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
sarl $0x5, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jl 0x5df08
movq -0x8(%rbp), %rdi
callq 0x5df30
jmp 0x5def1
movl -0x14(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
orl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/regalloc.c
// Function: pushchunk
static void pushchunk(JanetcRegisterAllocator *ra) {
    /* Registers 240-255 are always allocated (reserved) */
    uint32_t chunk = ra->count == 7 ? 0xFFFF0000 : 0;
    int32_t newcount = ra->count + 1;
    if (newcount > ra->capacity) {
        int32_t newcapacity = newcount * 2;
        ra->chunks = janet_realloc(ra->chunks, (size_t) newcapacity * sizeof(uint32_t));
        if (!ra->chunks) {
            JANET_OUT_OF_MEMORY;
        }
        ra->capacity = newcapacity;
    }
    ra->chunks[ra->count] = chunk;
    ra->count = newcount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
xorl %eax, %eax
movl $0xffff0000, %ecx       # imm = 0xFFFF0000
cmpl $0x7, %edx
cmovel %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0x5dfd6
movl -0x10(%rbp), %eax
shll %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rsi
shlq $0x2, %rsi
callq 0x12840
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5dfcc
jmp 0x5df9e
movq 0x5204b(%rip), %rax     # 0xafff0
movq (%rax), %rdi
leaq 0x20055(%rip), %rsi     # 0x7e004
leaq 0x37c26(%rip), %rdx     # 0x95bdc
movl $0x5e, %ecx
movb $0x0, %al
callq 0x125f0
movl $0x1, %edi
callq 0x12a70
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/regalloc.c
// Function: janetc_regalloc_1
int32_t janetc_regalloc_1(JanetcRegisterAllocator *ra) {
    /* Get the nth bit in the array */
    int32_t bit, chunk, nchunks, reg;
    bit = -1;
    nchunks = ra->count;
    for (chunk = 0; chunk < nchunks; chunk++) {
        uint32_t block = ra->chunks[chunk];
        if (block == 0xFFFFFFFF) continue;
        bit = count_trailing_ones(block);
        break;
    }
    /* No reg found */
    if (bit == -1) {
        pushchunk(ra);
        bit = 0;
        chunk = nchunks;
    }
    /* set the bit at index bit in chunk */
    ra->chunks[chunk] |= ithbit(bit);
    reg = (chunk << 5) + bit;
    if (reg > ra->max)
        ra->max = reg;
    return reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5e05f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x5e045
jmp 0x5e054
movl -0x1c(%rbp), %eax
xorl $-0x1, %eax
tzcntl %eax, %eax
movl %eax, -0xc(%rbp)
jmp 0x5e05f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5e024
cmpl $-0x1, -0xc(%rbp)
jne 0x5e07b
movq -0x8(%rbp), %rdi
callq 0x5df30
movl $0x0, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
orl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
shll $0x5, %eax
addl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jle 0x5e0b8
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/regalloc.c
// Function: janetc_regalloc_check
int janetc_regalloc_check(JanetcRegisterAllocator *ra, int32_t reg) {
    int32_t chunk = reg >> 5;
    int32_t bit = reg & 0x1F;
    while (chunk >= ra->count) pushchunk(ra);
    return !!(ra->chunks[chunk] & ithbit(bit));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
sarl $0x5, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jl 0x5e148
movq -0x8(%rbp), %rdi
callq 0x5df30
jmp 0x5e131
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl -0x14(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)