LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/../scg.h
// Function: scg__mouse_update
static void scg__mouse_update(scg_mouse_t *mouse, int w, int h, int win_w,
                              int win_h) {
    int x, y;
    uint32_t button_state = SDL_GetMouseState(&x, &y);

    mouse->window_x = x;
    mouse->window_y = y;
    mouse->x = (int)(((float32_t)x / (float32_t)win_w) * (float32_t)w);
    mouse->y = (int)(((float32_t)y / (float32_t)win_h) * (float32_t)h);
    mouse->button_state = button_state;
}

// 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)
movl %r8d, -0x18(%rbp)
leaq -0x1c(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2360
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
cvtsi2ssl -0x1c(%rbp), %xmm0
cvtsi2ssl -0x14(%rbp), %xmm1
divss %xmm1, %xmm0
cvtsi2ssl -0xc(%rbp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
cvtsi2ssl -0x20(%rbp), %xmm0
cvtsi2ssl -0x18(%rbp), %xmm1
divss %xmm1, %xmm0
cvtsi2ssl -0x10(%rbp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/../scg.h
// Function: scg__decode_font_data
static void scg__decode_font_data(char *out, size_t out_len, const char *data) {
    const int len = strlen(data);

    uint8_t indices[4];
    uint8_t buf[3];
    size_t size = 0;

    for (int i = 0; i < len; i += 4) {
        indices[0] = scg__base64_index_from_char(data[i]);
        indices[1] = scg__base64_index_from_char(data[i + 1]);
        indices[2] = scg__base64_index_from_char(data[i + 2]);
        indices[3] = scg__base64_index_from_char(data[i + 3]);

        buf[0] = (indices[0] << 2) + ((indices[1] & 0x30) >> 4);
        buf[1] = ((indices[1] & 0xF) << 4) + ((indices[2] & 0x3C) >> 2);
        buf[2] = ((indices[2] & 0x3) << 6) + indices[3];

        for (int j = 0; j < 3; j++) {
            if (size == out_len) {
                return;
            }

            out[size++] = buf[j];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20f0
movl %eax, -0x1c(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x569e
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x6c50
movb %al, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
callq 0x6c50
movb %al, -0x1f(%rbp)
movq -0x18(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
callq 0x6c50
movb %al, -0x1e(%rbp)
movq -0x18(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
callq 0x6c50
movb %al, -0x1d(%rbp)
movzbl -0x20(%rbp), %eax
shll $0x2, %eax
movzbl -0x1f(%rbp), %ecx
andl $0x30, %ecx
sarl $0x4, %ecx
addl %ecx, %eax
movb %al, -0x23(%rbp)
movzbl -0x1f(%rbp), %eax
andl $0xf, %eax
shll $0x4, %eax
movzbl -0x1e(%rbp), %ecx
andl $0x3c, %ecx
sarl $0x2, %ecx
addl %ecx, %eax
movb %al, -0x22(%rbp)
movzbl -0x1e(%rbp), %eax
andl $0x3, %eax
shll $0x6, %eax
movzbl -0x1d(%rbp), %ecx
addl %ecx, %eax
movb %al, -0x21(%rbp)
movl $0x0, -0x38(%rbp)
cmpl $0x3, -0x38(%rbp)
jge 0x568e
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x5665
jmp 0x569e
movslq -0x38(%rbp), %rax
movb -0x23(%rbp,%rax), %dl
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movb %dl, (%rax,%rcx)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x5653
jmp 0x5690
movl -0x34(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x34(%rbp)
jmp 0x559f
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/../scg.h
// Function: scg_app_present
void scg_app_present(scg_app_t *app) {
    if (app->config.video.show_frame_metrics) {
        scg_image_draw_frame_metrics(app->draw_target,
                                     app->screen->frame_metrics);
    }

    scg__keyboard_update_keystates(app->keyboard);

    if (app->audio != NULL) {
        scg__audio_update(app->audio);
    }

    scg__screen_present(app->screen, app->draw_target);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x27(%rax)
je 0x5851
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
addq $0x28, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x43f0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x58a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x5876
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x58d0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x5a20
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/../scg.h
// Function: scg_app_free
void scg_app_free(scg_app_t *app) {
    if (app->audio != NULL) {
        scg__audio_free(app->audio);
    }

    free(app->mouse);
    free(app->keyboard);
    scg__screen_free(app->screen);
    scg_image_free(app->draw_target);

    SDL_Quit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x5cd4
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x5d20
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2290
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2290
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x5420
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x4670
callq 0x2060
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/../scg.h
// Function: scg__audio_free
static void scg__audio_free(scg_audio_t *audio) {
    SDL_PauseAudioDevice(audio->device_id, 1);
    SDL_ClearQueuedAudio(audio->device_id);

    for (int i = 0; i < audio->num_sounds; i++) {
        SDL_FreeWAV(audio->sounds[i]->buffer);
    }

    free(audio->buffer);
    SDL_CloseAudioDevice(audio->device_id);

    free(audio);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
movl $0x1, %esi
callq 0x22d0
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x2340
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xa0(%rcx), %eax
jge 0x5d7e
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x20(%rax,%rcx,8), %rax
movq 0x30(%rax), %rdi
callq 0x2310
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5d4e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2290
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x20d0
movq -0x8(%rbp), %rdi
callq 0x2290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/../scg.h
// Function: scg_tween_exponential_ease_in_out
float32_t scg_tween_exponential_ease_in_out(float32_t t) {
    if (t == 0.0f || t == 1.0f) {
        return t;
    }

    if (t < 0.5f) {
        return 0.5f * powf(2.0f, (20.0f * t) - 10.0f);
    }

    return -0.5f * powf(2.0f, (-20.0f * t) + 10.0f) + 1.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x5ebe
jp 0x5ebe
jmp 0x5ed2
movss -0x8(%rbp), %xmm0
movss 0x113d(%rip), %xmm1     # 0x7008
ucomiss %xmm1, %xmm0
jne 0x5ee1
jp 0x5ee1
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x5f76
movss 0x111b(%rip), %xmm0     # 0x7004
ucomiss -0x8(%rbp), %xmm0
jbe 0x5f2f
movss -0x8(%rbp), %xmm1
movss 0x1128(%rip), %xmm0     # 0x7024
mulss %xmm0, %xmm1
movss 0x1110(%rip), %xmm0     # 0x7018
addss %xmm0, %xmm1
movss 0x10fc(%rip), %xmm0     # 0x7010
callq 0x2330
movaps %xmm0, %xmm1
movss 0x10e0(%rip), %xmm0     # 0x7004
mulss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x5f76
movss -0x8(%rbp), %xmm1
movss 0x10e4(%rip), %xmm0     # 0x7020
mulss %xmm0, %xmm1
movss 0x10cc(%rip), %xmm0     # 0x7014
addss %xmm0, %xmm1
movss 0x10bc(%rip), %xmm0     # 0x7010
callq 0x2330
movss 0x10bb(%rip), %xmm1     # 0x701c
mulss %xmm1, %xmm0
movss 0x109b(%rip), %xmm1     # 0x7008
addss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/../scg.h
// Function: scg_tween_elastic_ease_in
float32_t scg_tween_elastic_ease_in(float32_t t) {
    if (t == 0.0f) {
        return 0.0f;
    }

    if (t == 1.0f) {
        return 1.0f;
    }

    return -powf(2.0f, 10.0f * (t - 1.0f)) * sinf((t - 1.1f) * 5.0f * SCG_PI);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x5fb9
jp 0x5fb9
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x6057
movss -0x8(%rbp), %xmm0
movss 0x1042(%rip), %xmm1     # 0x7008
ucomiss %xmm1, %xmm0
jne 0x5fdc
jp 0x5fdc
movss 0x1033(%rip), %xmm0     # 0x7008
movss %xmm0, -0x4(%rbp)
jmp 0x6057
movss -0x8(%rbp), %xmm0
movss 0x101f(%rip), %xmm1     # 0x7008
subss %xmm1, %xmm0
movss 0x101f(%rip), %xmm1     # 0x7014
mulss %xmm0, %xmm1
movss 0x100f(%rip), %xmm0     # 0x7010
callq 0x2330
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
movss 0x100b(%rip), %xmm1     # 0x7030
subss %xmm1, %xmm0
movss 0xffb(%rip), %xmm1      # 0x702c
mulss %xmm1, %xmm0
movss 0xfeb(%rip), %xmm1      # 0x7028
mulss %xmm1, %xmm0
callq 0x21d0
movaps %xmm0, %xmm1
movss -0xc(%rbp), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/../scg.h
// Function: scg_tween_elastic_ease_out
float32_t scg_tween_elastic_ease_out(float32_t t) {
    if (t == 0.0f) {
        return 0.0f;
    }

    if (t == 1.0f) {
        return 1.0f;
    }

    return powf(2.0f, -10.0f * t) * sinf((t - 0.1f) * 5.0f * SCG_PI) + 1.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x6099
jp 0x6099
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x6126
movss -0x8(%rbp), %xmm0
movss 0xf62(%rip), %xmm1      # 0x7008
ucomiss %xmm1, %xmm0
jne 0x60bc
jp 0x60bc
movss 0xf53(%rip), %xmm0      # 0x7008
movss %xmm0, -0x4(%rbp)
jmp 0x6126
movss 0xf54(%rip), %xmm1      # 0x7018
mulss -0x8(%rbp), %xmm1
movss 0xf3f(%rip), %xmm0      # 0x7010
callq 0x2330
movss %xmm0, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
movss 0xf4c(%rip), %xmm1      # 0x7034
subss %xmm1, %xmm0
movss 0xf38(%rip), %xmm1      # 0x702c
mulss %xmm1, %xmm0
movss 0xf28(%rip), %xmm1      # 0x7028
mulss %xmm1, %xmm0
callq 0x21d0
movaps %xmm0, %xmm1
movss -0xc(%rbp), %xmm0
mulss %xmm1, %xmm0
movss 0xeeb(%rip), %xmm1      # 0x7008
addss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/../scg.h
// Function: scg_tween_elastic_ease_in_out
float32_t scg_tween_elastic_ease_in_out(float32_t t) {
    if (t == 0.0f) {
        return 0.0f;
    }

    if (t == 1.0f) {
        return 1.0f;
    }

    t *= 2.0f;

    if (t < 1.0f) {
        return -0.5f * powf(2.0f, 10.0f * (t - 1.0f)) *
               sinf((t - 1.1f) * 5.0f * SCG_PI);
    }

    return 0.5f * powf(2.0f, -10.0f * (t - 1.0f)) *
               sinf((t - 1.1f) * 5.0f * SCG_PI) +
           1.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x6169
jp 0x6169
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x62be
movss -0x8(%rbp), %xmm0
movss 0xe92(%rip), %xmm1      # 0x7008
ucomiss %xmm1, %xmm0
jne 0x618f
jp 0x618f
movss 0xe83(%rip), %xmm0      # 0x7008
movss %xmm0, -0x4(%rbp)
jmp 0x62be
movss 0xe79(%rip), %xmm0      # 0x7010
mulss -0x8(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movss 0xe5f(%rip), %xmm0      # 0x7008
ucomiss -0x8(%rbp), %xmm0
jbe 0x6235
movss -0x8(%rbp), %xmm0
movss 0xe48(%rip), %xmm1      # 0x7008
subss %xmm1, %xmm0
movss 0xe48(%rip), %xmm1      # 0x7014
mulss %xmm0, %xmm1
movss 0xe38(%rip), %xmm0      # 0x7010
callq 0x2330
movaps %xmm0, %xmm1
movss 0xe34(%rip), %xmm0      # 0x701c
mulss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
movss 0xe32(%rip), %xmm1      # 0x7030
subss %xmm1, %xmm0
movss 0xe22(%rip), %xmm1      # 0x702c
mulss %xmm1, %xmm0
movss 0xe12(%rip), %xmm1      # 0x7028
mulss %xmm1, %xmm0
callq 0x21d0
movaps %xmm0, %xmm1
movss -0xc(%rbp), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x62be
movss -0x8(%rbp), %xmm0
movss 0xdc6(%rip), %xmm1      # 0x7008
subss %xmm1, %xmm0
movss 0xdca(%rip), %xmm1      # 0x7018
mulss %xmm0, %xmm1
movss 0xdb6(%rip), %xmm0      # 0x7010
callq 0x2330
movaps %xmm0, %xmm1
movss 0xd9a(%rip), %xmm0      # 0x7004
mulss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x8(%rbp), %xmm0
movss 0xdb0(%rip), %xmm1      # 0x7030
subss %xmm1, %xmm0
movss 0xda0(%rip), %xmm1      # 0x702c
mulss %xmm1, %xmm0
movss 0xd90(%rip), %xmm1      # 0x7028
mulss %xmm1, %xmm0
callq 0x21d0
movaps %xmm0, %xmm1
movss -0x10(%rbp), %xmm0
mulss %xmm1, %xmm0
movss 0xd53(%rip), %xmm1      # 0x7008
addss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/../scg.h
// Function: scg_tween_definition_new
scg_tween_definition_t scg_tween_definition_new(scg_vec2f_t *start_end_values,
                                                int num_values,
                                                scg_tween_func_t func,
                                                float32_t duration, bool loop,
                                                bool yoyo) {
    return (scg_tween_definition_t){.start_end_values = start_end_values,
                                    .num_values = num_values,
                                    .func = func,
                                    .duration = duration,
                                    .loop = loop,
                                    .yoyo = yoyo};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %r9d, -0x2c(%rbp)
movl %r8d, %eax
movq %rcx, %r8
movl -0x2c(%rbp), %ecx
movq %r8, -0x28(%rbp)
movl %edx, %r8d
movq %rsi, %r9
movq -0x28(%rbp), %rsi
movb %al, %dl
movq %rdi, %rax
movq %r9, -0x8(%rbp)
movl %r8d, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
andb $0x1, %dl
movb %dl, -0x1d(%rbp)
andb $0x1, %cl
movb %cl, -0x1e(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, (%rdi)
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0x8(%rdi)
movl -0xc(%rbp), %ecx
movl %ecx, 0xc(%rdi)
movb -0x1d(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x10(%rdi)
movb -0x1e(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x11(%rdi)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rdi)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/../scg.h
// Function: scg_tween_start
void scg_tween_start(scg_tween_t *tween, float32_t current_time) {
    if (tween->playing) {
        return;
    }

    tween->playing = true;
    tween->start_time = current_time;
    tween->paused = false;
    tween->pause_time = 0.0f;
    tween->yoyo_in_progress = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x2c(%rax)
je 0x65b9
jmp 0x65eb
movq -0x8(%rbp), %rax
movb $0x1, 0x2c(%rax)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x28(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x2d(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x30(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x2e(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/../scg.h
// Function: scg_tween_stop
void scg_tween_stop(scg_tween_t *tween) {
    if (!tween->playing) {
        return;
    }

    tween->playing = false;
    tween->start_time = 0.0f;
    tween->paused = false;
    tween->pause_time = 0.0f;
    tween->yoyo_in_progress = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x2c(%rax)
jne 0x6604
jmp 0x6634
movq -0x8(%rbp), %rax
movb $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x28(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x2d(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x30(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x2e(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/../scg.h
// Function: scg_tween_pause
void scg_tween_pause(scg_tween_t *tween, float32_t current_time) {
    if (!tween->playing || tween->paused) {
        return;
    }

    tween->paused = true;
    tween->pause_time = current_time;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x2c(%rax)
je 0x6661
movq -0x8(%rbp), %rax
testb $0x1, 0x2d(%rax)
je 0x6663
jmp 0x6679
movq -0x8(%rbp), %rax
movb $0x1, 0x2d(%rax)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x30(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/../scg.h
// Function: scg_tween_resume
void scg_tween_resume(scg_tween_t *tween, float32_t current_time) {
    if (!tween->playing || !tween->paused) {
        return;
    }

    tween->paused = false;
    tween->start_time += current_time - tween->pause_time;
    tween->pause_time = 0.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x2c(%rax)
je 0x66a1
movq -0x8(%rbp), %rax
testb $0x1, 0x2d(%rax)
jne 0x66a3
jmp 0x66d3
movq -0x8(%rbp), %rax
movb $0x0, 0x2d(%rax)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
subss 0x30(%rax), %xmm0
movq -0x8(%rbp), %rax
addss 0x28(%rax), %xmm0
movss %xmm0, 0x28(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/../scg.h
// Function: scg__get_monitor_refresh_rate
static int scg__get_monitor_refresh_rate(SDL_DisplayMode display_mode) {
    int result = display_mode.refresh_rate;

    if (result == 0) {
        return SCG__DEFAULT_REFRESH_RATE;
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x69ed
movl $0x3c, -0x4(%rbp)
jmp 0x69f3
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/../scg.h
// Function: scg__base64_index_from_char
static uint8_t scg__base64_index_from_char(char c) {
    for (int i = 0; i < 64; i++) {
        if (c == scg__base64_table[i]) {
            return i;
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x40, -0x8(%rbp)
jge 0x6c93
movsbl -0x2(%rbp), %eax
movslq -0x8(%rbp), %rdx
leaq 0x159a(%rip), %rcx      # 0x8210
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x6c86
movl -0x8(%rbp), %eax
movb %al, -0x1(%rbp)
jmp 0x6c97
jmp 0x6c88
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x6c61
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/pgn.c
// Function: searchForPgn
const Pgn *searchForPgn(int pgn)
{
  size_t start = 0;
  size_t end   = pgnListSize;
  size_t mid;

  while (start <= end)
  {
    mid = (start + end) / 2;
    if (pgn == pgnList[mid].pgn)
    {
      // Return the first one, unless it is the catch-all
      while (mid > 0 && pgn == pgnList[mid - 1].pgn)
      {
        mid--;
      }
      if (pgnList[mid].fallback)
      {
        mid++;
        if (pgn != pgnList[mid].pgn)
        {
          return NULL;
        }
      }
      return &pgnList[mid];
    }
    if (pgn < pgnList[mid].pgn)
    {
      if (mid == 0)
      {
        return NULL;
      }
      end = mid - 1;
    }
    else
    {
      start = mid + 1;
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0x16f92(%rip), %rax     # 0x24438
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0xd5e1
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
shrq %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
leaq 0x2ee2c(%rip), %rcx     # 0x3c300
imulq $0x15f8, -0x28(%rbp), %rdx # imm = 0x15F8
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jne 0xd597
jmp 0xd4ea
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x29(%rbp)
jbe 0xd51b
movl -0xc(%rbp), %eax
movq -0x28(%rbp), %rdx
subq $0x1, %rdx
leaq 0x2edf8(%rip), %rcx     # 0x3c300
imulq $0x15f8, %rdx, %rdx     # imm = 0x15F8
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xd524
jmp 0xd532
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xd4ea
leaq 0x2edc7(%rip), %rax     # 0x3c300
imulq $0x15f8, -0x28(%rbp), %rcx # imm = 0x15F8
addq %rcx, %rax
testb $0x1, 0x15d0(%rax)
je 0xd57f
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
leaq 0x2ed9d(%rip), %rcx     # 0x3c300
imulq $0x15f8, -0x28(%rbp), %rdx # imm = 0x15F8
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
je 0xd57d
movq $0x0, -0x8(%rbp)
jmp 0xd5e9
jmp 0xd57f
leaq 0x2ed7a(%rip), %rax     # 0x3c300
imulq $0x15f8, -0x28(%rbp), %rcx # imm = 0x15F8
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xd5e9
movl -0xc(%rbp), %eax
leaq 0x2ed5f(%rip), %rcx     # 0x3c300
imulq $0x15f8, -0x28(%rbp), %rdx # imm = 0x15F8
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jae 0xd5d0
cmpq $0x0, -0x28(%rbp)
jne 0xd5c2
movq $0x0, -0x8(%rbp)
jmp 0xd5e9
movq -0x28(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xd5dc
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xd4ad
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/pgn.c
// Function: searchForUnknownPgn
const Pgn *searchForUnknownPgn(int pgnId)
{
  Pgn *fallback = pgnList;
  Pgn *pgn;

  for (pgn = pgnList; pgn < pgnList + pgnListSize; pgn++)
  {
    if (pgn->fallback)
    {
      fallback = pgn;
    }
    if (pgn->pgn >= pgnId)
    {
      break;
    }
  }
  if (fallback == NULL)
  {
    logAbort("Cannot find catch-all PGN definition for PGN %d; internal definition error\n", pgnId);
  }
  logDebug("Found catch-all PGN %u for PGN %d\n", fallback->pgn, pgnId);
  return fallback;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2ecfe(%rip), %rax     # 0x3c300
movq %rax, -0x10(%rbp)
leaq 0x2ecf3(%rip), %rax     # 0x3c300
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x2ece4(%rip), %rcx     # 0x3c300
leaq 0x16e15(%rip), %rdx     # 0x24438
imulq $0x15f8, (%rdx), %rdx   # imm = 0x15F8
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0xd667
movq -0x18(%rbp), %rax
testb $0x1, 0x15d0(%rax)
je 0xd647
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x4(%rbp), %eax
jb 0xd655
jmp 0xd667
jmp 0xd657
movq -0x18(%rbp), %rax
addq $0x15f8, %rax           # imm = 0x15F8
movq %rax, -0x18(%rbp)
jmp 0xd611
cmpq $0x0, -0x10(%rbp)
jne 0xd67f
movl -0x4(%rbp), %esi
leaq 0x1698c(%rip), %rdi     # 0x24004
movb $0x0, %al
callq 0x1f7d0
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movl -0x4(%rbp), %edx
leaq 0x169c0(%rip), %rdi     # 0x24050
movb $0x0, %al
callq 0x1f670
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/pgn.c
// Function: getField
const Field *getField(uint32_t pgnId, uint32_t field)
{
  const Pgn *pgn = searchForPgn(pgnId);

  if (!pgn)
  {
    logDebug("PGN %u is unknown\n", pgnId);
    return 0;
  }
  if (field < pgn->fieldCount)
  {
    return pgn->fieldList + field;
  }
  logDebug("PGN %u does not have field %u\n", pgnId, field);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl -0xc(%rbp), %edi
callq 0xd490
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xdc2c
movl -0xc(%rbp), %esi
leaq 0x16736(%rip), %rdi     # 0x24351
movb $0x0, %al
callq 0x1f670
movq $0x0, -0x8(%rbp)
jmp 0xdc72
movl -0x10(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x15c0(%rcx), %eax
jae 0xdc56
movq -0x18(%rbp), %rax
addq $0x18, %rax
movl -0x10(%rbp), %ecx
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xdc72
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0x16701(%rip), %rdi     # 0x24364
movb $0x0, %al
callq 0x1f670
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/pgn.c
// Function: camelize
static char *camelize(const char *str, bool upperCamelCase, int order)
{
  size_t      len         = strlen(str);
  char       *ptr         = malloc(len + 4);
  char       *p           = ptr;
  const char *s           = str;
  bool        lastIsAlpha = !upperCamelCase;

  if (p == NULL)
  {
    return NULL;
  }

  for (; *s; s++)
  {
    if (isalpha((unsigned char) *s) || isdigit((unsigned char) *s))
    {
      if (lastIsAlpha)
      {
        *p = tolower(*s);
      }
      else
      {
        *p          = toupper(*s);
        lastIsAlpha = true;
      }
      p++;
    }
    else
    {
      lastIsAlpha = false;
    }
  }

  if (order > 0 && (strcmp(str, "Reserved") == 0 || strcmp(str, "Spare") == 0))
  {
    sprintf(p, "%u", order);
  }
  else
  {
    *p = 0;
  }
  return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd0d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
callq 0xd200
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb -0x11(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x39(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xdf73
movq $0x0, -0x8(%rbp)
jmp 0xe071
jmp 0xdf75
movq -0x38(%rbp), %rax
cmpb $0x0, (%rax)
je 0xe01b
callq 0xd350
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0xdfc2
callq 0xd350
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0xe004
testb $0x1, -0x39(%rbp)
je 0xdfde
movq -0x38(%rbp), %rax
movsbl (%rax), %edi
callq 0xd1f0
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
jmp 0xdff6
movq -0x38(%rbp), %rax
movsbl (%rax), %edi
callq 0xd0a0
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movb $0x1, -0x39(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xe008
movb $0x0, -0x39(%rbp)
jmp 0xe00a
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xdf75
cmpl $0x0, -0x18(%rbp)
jle 0xe062
movq -0x10(%rbp), %rdi
leaq 0x16357(%rip), %rsi     # 0x24383
callq 0xd190
cmpl $0x0, %eax
je 0xe04b
movq -0x10(%rbp), %rdi
leaq 0x1634b(%rip), %rsi     # 0x2438c
callq 0xd190
cmpl $0x0, %eax
jne 0xe062
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x27f08(%rip), %rsi     # 0x35f61
movb $0x0, %al
callq 0xd2d0
jmp 0xe069
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/analyzer-explain.c
// Function: usage
static void usage(char **argv, char **av)
{
  if (av != NULL)
  {
    printf("Unknown or invalid argument %s\n", av[0]);
  }
  printf("Usage: %s -explain | -explain-xml | -explain-ngt-xml | -explain-ik-xml"
         " | [-camel] | [-upper-camel]"
         " | [-version]\n",
         argv[0]);
  printf("     -explain          Export the PGN database in text format\n");
  printf("     -explain-xml      Export the PGN database in XML format\n");
  printf("     -explain-ngt-xml  Export the Actisense PGN database in XML format\n");
  printf("     -explain-ik-xml   Export the iKonvert PGN database in XML format\n");
  printf("     -v1               v1 format: Explain lookups everywhere they are used\n");
  printf("     -camel            Show fieldnames in normalCamelCase\n");
  printf("     -upper-camel      Show fieldnames in UpperCamelCase\n");
  printf("     -version          Print the version of the program and quit\n");
  printf("     -d                Print logging from level ERROR, INFO and DEBUG\n");
  printf("\n");
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xe30c
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x18f3f(%rip), %rdi     # 0x27244
movb $0x0, %al
callq 0xd0f0
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x18f4a(%rip), %rdi     # 0x27264
movb $0x0, %al
callq 0xd0f0
leaq 0x18fad(%rip), %rdi     # 0x272d5
movb $0x0, %al
callq 0xd0f0
leaq 0x18fde(%rip), %rdi     # 0x27314
movb $0x0, %al
callq 0xd0f0
leaq 0x1900e(%rip), %rdi     # 0x27352
movb $0x0, %al
callq 0xd0f0
leaq 0x19048(%rip), %rdi     # 0x2739a
movb $0x0, %al
callq 0xd0f0
leaq 0x19081(%rip), %rdi     # 0x273e1
movb $0x0, %al
callq 0xd0f0
leaq 0x190bf(%rip), %rdi     # 0x2742d
movb $0x0, %al
callq 0xd0f0
leaq 0x190ec(%rip), %rdi     # 0x27468
movb $0x0, %al
callq 0xd0f0
leaq 0x19118(%rip), %rdi     # 0x274a2
movb $0x0, %al
callq 0xd0f0
leaq 0x1914c(%rip), %rdi     # 0x274e4
movb $0x0, %al
callq 0xd0f0
leaq 0x195ae(%rip), %rdi     # 0x27954
movb $0x0, %al
callq 0xd0f0
movl $0x1, %edi
callq 0xd2e0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/analyzer-explain.c
// Function: explain
static void explain(void)
{
  int i;

  printf(COPYRIGHT "\n\nThis program can understand a number of N2K messages. What follows is an explanation of the messages\n"
                   "that it understands. First is a list of completely understood messages, as far as I can tell.\n"
                   "What follows is a list of messages that contain fields that have unknown content or size, or even\n"
                   "completely unknown fields. If you happen to know more, please tell me!\n\n");
  printf("_______ Complete PGNs _________\n\n");
  for (i = 1; i < ARRAY_SIZE(pgnList); i++)
  {
    if (pgnList[i].complete == PACKET_COMPLETE && pgnList[i].pgn < ACTISENSE_BEM)
    {
      explainPGN(pgnList[i]);
    }
  }
  printf("_______ Incomplete PGNs _________\n\n");
  for (i = 1; i < ARRAY_SIZE(pgnList); i++)
  {
    if (pgnList[i].complete != PACKET_COMPLETE && pgnList[i].pgn < ACTISENSE_BEM)
    {
      explainPGN(pgnList[i]);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1600, %rsp           # imm = 0x1600
leaq 0x19159(%rip), %rdi     # 0x2752b
movb $0x0, %al
callq 0xd0f0
leaq 0x19576(%rip), %rdi     # 0x27956
movb $0x0, %al
callq 0xd0f0
movl $0x1, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0x38, %rax
jae 0xe466
movslq -0x4(%rbp), %rcx
leaq 0x2defd(%rip), %rax     # 0x3c300
imulq $0x15f8, %rcx, %rcx     # imm = 0x15F8
addq %rcx, %rax
movzwl 0xc(%rax), %eax
cmpl $0x0, %eax
jne 0xe459
movslq -0x4(%rbp), %rcx
leaq 0x2dedf(%rip), %rax     # 0x3c300
imulq $0x15f8, %rcx, %rcx     # imm = 0x15F8
addq %rcx, %rax
cmpl $0x40000, 0x8(%rax)     # imm = 0x40000
jae 0xe459
movslq -0x4(%rbp), %rax
leaq 0x2dec1(%rip), %rsi     # 0x3c300
imulq $0x15f8, %rax, %rax     # imm = 0x15F8
addq %rax, %rsi
movq %rsp, %rdi
movl $0x2bf, %ecx            # imm = 0x2BF
rep  movsq (%rsi), %es:(%rdi)
callq 0xea00
jmp 0xe45b
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xe3ee
leaq 0x1950b(%rip), %rdi     # 0x27978
movb $0x0, %al
callq 0xd0f0
movl $0x1, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0x38, %rax
jae 0xe4f3
movslq -0x4(%rbp), %rcx
leaq 0x2de70(%rip), %rax     # 0x3c300
imulq $0x15f8, %rcx, %rcx     # imm = 0x15F8
addq %rcx, %rax
movzwl 0xc(%rax), %eax
cmpl $0x0, %eax
je 0xe4e6
movslq -0x4(%rbp), %rcx
leaq 0x2de52(%rip), %rax     # 0x3c300
imulq $0x15f8, %rcx, %rcx     # imm = 0x15F8
addq %rcx, %rax
cmpl $0x40000, 0x8(%rax)     # imm = 0x40000
jae 0xe4e6
movslq -0x4(%rbp), %rax
leaq 0x2de34(%rip), %rsi     # 0x3c300
imulq $0x15f8, %rax, %rax     # imm = 0x15F8
addq %rax, %rsi
movq %rsp, %rdi
movl $0x2bf, %ecx            # imm = 0x2BF
rep  movsq (%rsi), %es:(%rdi)
callq 0xea00
jmp 0xe4e8
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xe47b
addq $0x1600, %rsp           # imm = 0x1600
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/analyzer-explain.c
// Function: explainPhysicalQuantityXML
static void explainPhysicalQuantityXML(void)
{
  printf("  <PhysicalQuantities>\n");
  for (size_t i = 0; PhysicalQuantityList[i] != NULL; i++)
  {
    const PhysicalQuantity *pq = PhysicalQuantityList[i];

    printf("    <PhysicalQuantity Name=\"%s\">\n", pq->name);
    if (pq->description != NULL)
    {
      printf("      <Description>%s</Description>\n", pq->description);
    }
    if (pq->comment != NULL)
    {
      printf("      <Comment>%s</Comment>\n", pq->comment);
    }
    if (pq->url != NULL)
    {
      printf("      <URL>%s</URL>\n", pq->url);
    }
    if (pq->unit != NULL)
    {
      printf("      <UnitDescription>%s</UnitDescription>\n", pq->unit);
    }
    if (pq->abbreviation != NULL)
    {
      printf("      <Unit>%s</Unit>\n", pq->abbreviation);
    }
    printf("    </PhysicalQuantity>\n");
  }
  printf("  </PhysicalQuantities>\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x19719(%rip), %rdi     # 0x28ac8
movb $0x0, %al
callq 0xd0f0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rcx
leaq 0x2c927(%rip), %rax     # 0x3bcf0
cmpq $0x0, (%rax,%rcx,8)
je 0xf4c0
movq -0x8(%rbp), %rcx
leaq 0x2c911(%rip), %rax     # 0x3bcf0
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x196eb(%rip), %rdi     # 0x28ae0
movb $0x0, %al
callq 0xd0f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xf41d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x196ec(%rip), %rdi     # 0x28b02
movb $0x0, %al
callq 0xd0f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xf43e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x196f0(%rip), %rdi     # 0x28b27
movb $0x0, %al
callq 0xd0f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xf45f
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
leaq 0x196ec(%rip), %rdi     # 0x28b44
movb $0x0, %al
callq 0xd0f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xf480
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
leaq 0x196e0(%rip), %rdi     # 0x28b59
movb $0x0, %al
callq 0xd0f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xf4a1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x196ec(%rip), %rdi     # 0x28b86
movb $0x0, %al
callq 0xd0f0
leaq 0x196f5(%rip), %rdi     # 0x28b9d
movb $0x0, %al
callq 0xd0f0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xf3be
leaq 0x196ef(%rip), %rdi     # 0x28bb6
movb $0x0, %al
callq 0xd0f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/analyzer-explain.c
// Function: explainMissingXML
static void explainMissingXML(void)
{
  printf("  <MissingEnumerations>\n");
  printf("    <MissingAttribute Name=\"%s\">%s</MissingAttribute>\n",
         "Fields",
         "The list of fields is incomplete; some fields maybe be missing or their attributes may be incorrect");
  printf("    <MissingAttribute Name=\"%s\">%s</MissingAttribute>\n",
         "FieldLengths",
         "The length of one or more fields is likely incorrect");
  printf("    <MissingAttribute Name=\"%s\">%s</MissingAttribute>\n",
         "Resolution",
         "The resolution of one or more fields is likely incorrect");
  printf("    <MissingAttribute Name=\"%s\">%s</MissingAttribute>\n",
         "Lookups",
         "One or more of the lookup fields contain missing or incorrect values");
  printf(
      "    <MissingAttribute Name=\"%s\">%s</MissingAttribute>\n", "SampleData", "The PGN has not been seen in any logfiles yet");
  printf("    <MissingAttribute Name=\"%s\">%s</MissingAttribute>\n", "Interval", "The default transmission interval is not known");
  printf("    <MissingAttribute Name=\"%s\">%s</MissingAttribute>\n",
         "MissingCompanyFields",
         "The manufacturer specific PGN seems to not contain the mandatory Company and Industry fields; this is likely a bug or at "
         "least incompatibility in the device");

  printf("  </MissingEnumerations>\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x19506(%rip), %rdi     # 0x28ce1
movb $0x0, %al
callq 0xd0f0
leaq 0x19511(%rip), %rdi     # 0x28cfa
leaq 0x1fa8f(%rip), %rsi     # 0x2f27f
leaq 0x1953a(%rip), %rdx     # 0x28d31
movb $0x0, %al
callq 0xd0f0
leaq 0x194f5(%rip), %rdi     # 0x28cfa
leaq 0x19589(%rip), %rsi     # 0x28d95
leaq 0x1958f(%rip), %rdx     # 0x28da2
movb $0x0, %al
callq 0xd0f0
leaq 0x194d9(%rip), %rdi     # 0x28cfa
leaq 0x195af(%rip), %rsi     # 0x28dd7
leaq 0x195b3(%rip), %rdx     # 0x28de2
movb $0x0, %al
callq 0xd0f0
leaq 0x194bd(%rip), %rdi     # 0x28cfa
leaq 0x195d7(%rip), %rsi     # 0x28e1b
leaq 0x195d8(%rip), %rdx     # 0x28e23
movb $0x0, %al
callq 0xd0f0
leaq 0x194a1(%rip), %rdi     # 0x28cfa
leaq 0x19608(%rip), %rsi     # 0x28e68
leaq 0x1960c(%rip), %rdx     # 0x28e73
movb $0x0, %al
callq 0xd0f0
leaq 0x19485(%rip), %rdi     # 0x28cfa
leaq 0x19b1c(%rip), %rsi     # 0x29398
leaq 0x1961e(%rip), %rdx     # 0x28ea1
movb $0x0, %al
callq 0xd0f0
leaq 0x19469(%rip), %rdi     # 0x28cfa
leaq 0x19638(%rip), %rsi     # 0x28ed0
leaq 0x19646(%rip), %rdx     # 0x28ee5
movb $0x0, %al
callq 0xd0f0
leaq 0x196d5(%rip), %rdi     # 0x28f82
movb $0x0, %al
callq 0xd0f0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/analyzer-explain.c
// Function: explainFieldtypeXMLv2
static void explainFieldtypeXMLv2(size_t n, const char *s, const char *fts, const LookupInfo *lookup)
{
  FieldType *ft = getFieldType(fts);

  printf("      <EnumFieldType Value='%zu' Name='", n);
  printXML(0, 0, s);
  printf("'");

  if (ft != NULL)
  {
    printf(" FieldType='%s'", getV2Type(ft));
    if (ft->hasSign != Null)
    {
      printf(" Signed='%s'\n", ft->hasSign == True ? "true" : "false");
    }
    if (ft->resolution != 0.0)
    {
      printf(" Resolution='%g'", ft->resolution);
    }
    if (ft->unit != NULL)
    {
      printf(" Unit='%s'", ft->unit);
    }
    if (lookup != NULL && lookup->size != 0)
    {
      printf(" Bits='%zu'", lookup->size);
    }
    else if (ft->size != 0)
    {
      printf(" Bits='%u'", ft->size);
    }
  }
  if (lookup != NULL)
  {
    printf(">\n");
    explainLookupFunction(lookup);
    printf("      </EnumFieldType>\n");
  }
  else
  {
    printf("/>\n");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1dcf0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x19829(%rip), %rdi     # 0x29209
movb $0x0, %al
callq 0xd0f0
movq -0x10(%rbp), %rdx
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x10780
leaq 0x195f3(%rip), %rdi     # 0x28ff0
movb $0x0, %al
callq 0xd0f0
cmpq $0x0, -0x28(%rbp)
je 0xfaf8
movq -0x28(%rbp), %rdi
callq 0x108c0
movq %rax, %rsi
leaq 0x195f0(%rip), %rdi     # 0x29012
movb $0x0, %al
callq 0xd0f0
movq -0x28(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0xfa5d
movq -0x28(%rbp), %rax
movl 0x60(%rax), %ecx
leaq 0x181e5(%rip), %rsi     # 0x27c26
leaq 0x181d9(%rip), %rax     # 0x27c21
cmpl $0x2, %ecx
cmoveq %rax, %rsi
leaq 0x195cc(%rip), %rdi     # 0x29022
movb $0x0, %al
callq 0xd0f0
movq -0x28(%rbp), %rax
movsd 0x58(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xfa73
jp 0xfa73
jmp 0xfa8a
movq -0x28(%rbp), %rax
movsd 0x58(%rax), %xmm0
leaq 0x195ad(%rip), %rdi     # 0x29030
movb $0x1, %al
callq 0xd0f0
movq -0x28(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xfaab
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rsi
leaq 0x1959d(%rip), %rdi     # 0x29041
movb $0x0, %al
callq 0xd0f0
cmpq $0x0, -0x20(%rbp)
je 0xfad5
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xfad5
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
leaq 0x19580(%rip), %rdi     # 0x2904c
movb $0x0, %al
callq 0xd0f0
jmp 0xfaf6
movq -0x28(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0xfaf4
movq -0x28(%rbp), %rax
movl 0x28(%rax), %esi
leaq 0x1956b(%rip), %rdi     # 0x29058
movb $0x0, %al
callq 0xd0f0
jmp 0xfaf6
jmp 0xfaf8
cmpq $0x0, -0x20(%rbp)
je 0xfb26
leaq 0x188d7(%rip), %rdi     # 0x283dd
movb $0x0, %al
callq 0xd0f0
movq -0x20(%rbp), %rdi
callq 0x10910
leaq 0x19546(%rip), %rdi     # 0x29063
movb $0x0, %al
callq 0xd0f0
jmp 0xfb34
leaq 0x19471(%rip), %rdi     # 0x28f9e
movb $0x0, %al
callq 0xd0f0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/analyzer-explain.c
// Function: printXML
static void printXML(int indent, const char *element, const char *p)
{
  int i;

  if (p)
  {
    if (element)
    {
      for (i = 0; i < indent; i++)
      {
        fputs(" ", stdout);
      }
      printf("<%s>", element);
    }
    for (; *p; p++)
    {
      switch (*p)
      {
        case '&':
          fputs("&amp;", stdout);
          break;

        case '<':
          fputs("&lt;", stdout);
          break;

        case '>':
          fputs("&gt;", stdout);
          break;

        case '"':
          fputs("&quot;", stdout);
          break;

        default:
          putchar(*p);
      }
    }
    if (element)
    {
      printf("</%s>\n", element);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x108b9
cmpq $0x0, -0x10(%rbp)
je 0x107e7
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x107d5
movq 0x2b81d(%rip), %rax     # 0x3bfd8
movq (%rax), %rsi
leaq 0x173a3(%rip), %rdi     # 0x27b68
callq 0xd150
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x107ac
movq -0x10(%rbp), %rsi
leaq 0x187c2(%rip), %rdi     # 0x28fa2
movb $0x0, %al
callq 0xd0f0
jmp 0x107e9
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1089e
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
addl $-0x22, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x1c, %eax
ja 0x1087f
movq -0x28(%rbp), %rax
leaq 0x13b9a(%rip), %rcx     # 0x243b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x2b7b2(%rip), %rax     # 0x3bfd8
movq (%rax), %rsi
leaq 0x18777(%rip), %rdi     # 0x28fa7
callq 0xd150
jmp 0x1088b
movq 0x2b79a(%rip), %rax     # 0x3bfd8
movq (%rax), %rsi
leaq 0x18765(%rip), %rdi     # 0x28fad
callq 0xd150
jmp 0x1088b
movq 0x2b782(%rip), %rax     # 0x3bfd8
movq (%rax), %rsi
leaq 0x18752(%rip), %rdi     # 0x28fb2
callq 0xd150
jmp 0x1088b
movq 0x2b76a(%rip), %rax     # 0x3bfd8
movq (%rax), %rsi
leaq 0x1873f(%rip), %rdi     # 0x28fb7
callq 0xd150
jmp 0x1088b
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0xd040
jmp 0x1088d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x107e9
cmpq $0x0, -0x10(%rbp)
je 0x108b7
movq -0x10(%rbp), %rsi
leaq 0x1894c(%rip), %rdi     # 0x291fc
movb $0x0, %al
callq 0xd0f0
jmp 0x108b9
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/analyzer-explain.c
// Function: getV2Type
static const char *getV2Type(const FieldType *ft)
{
  for (; ft != NULL; ft = ft->baseFieldTypePtr)
  {
    if (ft->baseFieldTypePtr == NULL)
    {
      return ft->name;
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x108fd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x88(%rax)
jne 0x108ea
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x10905
jmp 0x108ec
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x108c8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/analyzer-explain.c
// Function: printXMLUnsigned
static void printXMLUnsigned(int indent, const char *element, const unsigned int p)
{
  int i;

  for (i = 0; i < indent; i++)
  {
    fputs(" ", stdout);
  }
  printf("<%s>%u</%s>\n", element, p, element);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x10b62
movq 0x2b490(%rip), %rax     # 0x3bfd8
movq (%rax), %rsi
leaq 0x17016(%rip), %rdi     # 0x27b68
callq 0xd150
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x10b39
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq 0x18682(%rip), %rdi     # 0x291f6
movb $0x0, %al
callq 0xd0f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/analyzer-explain.c
// Function: explainFieldtypeXMLv1
static void explainFieldtypeXMLv1(size_t n, const char *s, const char *fts, const LookupInfo *lookup)
{
  FieldType *ft = getFieldType(fts);

  printf("            <EnumFieldType Value='%zu' Name='", n);
  printXML(0, 0, s);
  printf("'");

  if (ft != NULL)
  {
    printf(" FieldType='%s'", getV1Type(ft, NULL));
    if (ft->hasSign != Null)
    {
      printf(" Signed='%s'\n", ft->hasSign == True ? "true" : "false");
    }
    if (ft->resolution != 0.0)
    {
      printf(" Resolution='%g'", ft->resolution);
    }
    if (ft->unit != NULL)
    {
      printf(" Unit='%s'", ft->unit);
    }
    if (lookup != NULL && lookup->size != 0)
    {
      printf(" Bits='%zu'", lookup->size);
    }
    else if (ft->size != 0)
    {
      printf(" Bits='%u'", ft->size);
    }
  }
  printf("/>\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1dcf0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x18643(%rip), %rdi     # 0x29203
movb $0x0, %al
callq 0xd0f0
movq -0x10(%rbp), %rdx
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x10780
leaq 0x18413(%rip), %rdi     # 0x28ff0
movb $0x0, %al
callq 0xd0f0
cmpq $0x0, -0x28(%rbp)
je 0x10cdc
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10cf0
movq %rax, %rsi
leaq 0x1840c(%rip), %rdi     # 0x29012
movb $0x0, %al
callq 0xd0f0
movq -0x28(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x10c41
movq -0x28(%rbp), %rax
movl 0x60(%rax), %ecx
leaq 0x17001(%rip), %rsi     # 0x27c26
leaq 0x16ff5(%rip), %rax     # 0x27c21
cmpl $0x2, %ecx
cmoveq %rax, %rsi
leaq 0x183e8(%rip), %rdi     # 0x29022
movb $0x0, %al
callq 0xd0f0
movq -0x28(%rbp), %rax
movsd 0x58(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x10c57
jp 0x10c57
jmp 0x10c6e
movq -0x28(%rbp), %rax
movsd 0x58(%rax), %xmm0
leaq 0x183c9(%rip), %rdi     # 0x29030
movb $0x1, %al
callq 0xd0f0
movq -0x28(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x10c8f
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rsi
leaq 0x183b9(%rip), %rdi     # 0x29041
movb $0x0, %al
callq 0xd0f0
cmpq $0x0, -0x20(%rbp)
je 0x10cb9
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x10cb9
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
leaq 0x1839c(%rip), %rdi     # 0x2904c
movb $0x0, %al
callq 0xd0f0
jmp 0x10cda
movq -0x28(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x10cd8
movq -0x28(%rbp), %rax
movl 0x28(%rax), %esi
leaq 0x18387(%rip), %rdi     # 0x29058
movb $0x0, %al
callq 0xd0f0
jmp 0x10cda
jmp 0x10cdc
leaq 0x182bb(%rip), %rdi     # 0x28f9e
movb $0x0, %al
callq 0xd0f0
addq $0x30, %rsp
popq %rbp
retq