LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/primitive.c
// Function: set_carB
static LakeVal *_set_carB(LakeCtx *ctx, LakeList *args)
{
    LakeList *list = LIST(LIST_VAL(args, 0));
    if (lake_is_type(TYPE_LIST, list))
    {
        LakeVal *new_car = LIST_VAL(args, 1);
        if (LIST_N(list) == 0)
        {
            list_append(list, new_car);
        }
        else
        {
            list_set(list, 0, new_car);
        }
        return VAL(list);
    }
    ERR("not a pair: %s", lake_repr(list));
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq 0x18(%rcx), %rax
jae 0x77cd
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x77d5
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x77d5
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl $0x5, %edi
callq 0x40d0
cmpl $0x0, %eax
je 0x7856
movq -0x18(%rbp), %rcx
movl $0x1, %eax
cmpq 0x18(%rcx), %rax
jae 0x7811
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x7819
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x7819
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x783b
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x47f0
jmp 0x784c
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x4940
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x78bc
jmp 0x7858
movq 0x5799(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x17f5(%rip), %rsi      # 0x905e
movb $0x0, %al
callq 0x1160
movq 0x5781(%rip), %rax      # 0xcff8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x40f0
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x1c87(%rip), %rsi      # 0x951c
movb $0x0, %al
callq 0x1160
movq 0x5755(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x1b33(%rip), %rsi      # 0x93e0
movb $0x0, %al
callq 0x1160
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/primitive.c
// Function: display
static LakeVal *_display(LakeCtx *ctx, LakeList *args)
{
    size_t n = LIST_N(args);
    size_t i;
    int space = 0;
    for (i = 0; i < n; ++i)
    {
        if (space) putchar(' ');
        printf("%s", lake_repr(LIST_VAL(args, i)));
        space = 1;
    }
    putchar('\n');
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x7977
cmpl $0x0, -0x24(%rbp)
je 0x7915
movl $0x20, %edi
callq 0x1040
cmpq $0x0, -0x20(%rbp)
jb 0x7940
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x7940
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
jmp 0x7948
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x7948
movq -0x30(%rbp), %rdi
callq 0x40f0
movq %rax, %rsi
leaq 0x171f(%rip), %rdi      # 0x907a
movb $0x0, %al
callq 0x10d0
movl $0x1, -0x24(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x78fb
movl $0xa, %edi
callq 0x1040
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/sym.c
// Function: sym_intern
LakeSym *sym_intern(LakeCtx *ctx, char *s)
{
    LakeSym *sym = lake_hash_get(ctx->symbols, s);
    if (!sym)
    {
        sym = sym_alloc();
        sym->n = strlen(s);
        sym->s = strndup(s, sym->n);
        sym->hash = str_hash(s);
        lake_hash_put(ctx->symbols, sym->s, sym);
    }
    return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x38c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7fc3
callq 0x7fd0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x1120
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x8010
movl %eax, %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x3540
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/sym.c
// Function: str_hash
static uint32_t str_hash(const char *s)
{
    char c;
    uint32_t h = 5381;

    while ((c = *s++))
        h = ((h << 5) + h) ^ c;

    return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x1505, -0x10(%rbp)    # imm = 0x1505
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0x9(%rbp)
cmpb $0x0, %al
je 0x804b
movl -0x10(%rbp), %eax
shll $0x5, %eax
addl -0x10(%rbp), %eax
movsbl -0x9(%rbp), %ecx
xorl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x801f
movl -0x10(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/repl.c
// Function: main
int main(int argc, char const *argv[])
{
    /* create an execution context */
    LakeCtx *ctx = lake_init();

    /* create and bind args */
    LakeVal **argVals = malloc(argc * sizeof(LakeVal *));
    int i;
    for (i = 0; i < argc; ++i)
    {
        argVals[i] = VAL(lake_str_from_c((char *)argv[i]));
    }
    LakeList *args = list_from_array(argc, argVals);
    free(argVals);
    env_define(ctx->toplevel, sym_intern(ctx, "args"), VAL(args));

    /* if a filename is given load the file */
    if (argc > 1)
    {
        char *text = read_file(argv[1]);
        if (text)
        {
            LakeList *exprs = parse_exprs(ctx, text, strlen(text));
            if (exprs)
            {
                eval_exprs(ctx, ctx->toplevel, exprs);
            }
        }
    }

    /* run the repl */
    run_repl(ctx, ctx->toplevel);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x4510
movq %rax, -0x18(%rbp)
movslq -0x8(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1190
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x818a
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7d20
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8157
movslq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4890
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x13e5(%rip), %rsi      # 0x959f
callq 0x7f30
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movq -0x30(%rbp), %rdx
callq 0x1a10
cmpl $0x1, -0x8(%rbp)
jle 0x8239
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8260
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x8237
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
callq 0x10b0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x5060
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x8235
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x40(%rbp), %rdx
callq 0x3100
jmp 0x8237
jmp 0x8239
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x8530
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/repl.c
// Function: run_repl
static void run_repl(LakeCtx *ctx, Env *env)
{
    puts("Lake Scheme v" LAKE_VERSION);
    LakeVal *expr;
    LakeVal *result;
    for (;;)
    {
        expr = prompt_read(ctx, env, "> ");
        if (expr == VAL(EOF)) break;
        if (expr == VAL(PARSE_ERR))
        {
            ERR("parse error");
            continue;
        }
        if (expr)
        {
            result = eval(ctx, env, expr);
            if (result) print(result);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1097(%rip), %rdi      # 0x95de
callq 0x1070
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x1094(%rip), %rdx      # 0x95ef
callq 0x8610
movq %rax, -0x18(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x18(%rbp)
jne 0x8576
jmp 0x8605
movq $-0x2, %rax
cmpq %rax, -0x18(%rbp)
jne 0x85d2
jmp 0x8585
movq 0x4a6c(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0xac8(%rip), %rsi       # 0x905e
movb $0x0, %al
callq 0x1160
movq 0x4a54(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x1044(%rip), %rsi      # 0x95f2
movb $0x0, %al
callq 0x1160
movq 0x4a3c(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0xe1a(%rip), %rsi       # 0x93e0
movb $0x0, %al
callq 0x1160
jmp 0x854c
cmpq $0x0, -0x18(%rbp)
je 0x8600
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2840
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x85fe
movq -0x20(%rbp), %rdi
callq 0x80f0
jmp 0x8600
jmp 0x854c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/samples/beatclock/beat.cpp
// Function: BeatClock::Mode()
Void BeatClock::Mode()
{
	if (modechange == 0)
	{
		if (centi) centi = False;
		else	   centi = True;
	}
	else if (modechange == 1)
	{
		switch (timeformat)
		{
			case 0:
				timeformat = 1;
				break;
			case 1:
				timeformat = 0;
				break;
		}
	}
	else if (modechange == 2)
	{
		switch (timezone)
		{
			case 0:
				timezone = 1;
				break;
			case 1:
				timezone = 0;
				break;
		}
	}
	else if (modechange == 3)
	{
		switch (timeformat)
		{
			case 0:
				timeformat = 1;
				break;
			case 1:
				timeformat = 0;
				break;
		}

		switch (timezone)
		{
			case 0:
				timezone = 1;
				break;
			case 1:
				timezone = 0;
				break;
		}
	}

	PaintAll();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x5fc(%rax)
jne 0x6197
movq -0x10(%rbp), %rax
testb $0x1, 0x5f0(%rax)
je 0x6187
movq -0x10(%rbp), %rax
movb $0x0, 0x5f0(%rax)
jmp 0x6192
movq -0x10(%rbp), %rax
movb $0x1, 0x5f0(%rax)
jmp 0x62bc
movq -0x10(%rbp), %rax
cmpl $0x1, 0x5fc(%rax)
jne 0x61e4
movq -0x10(%rbp), %rax
movl 0x5ec(%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x61c1
jmp 0x61b7
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x61d1
jmp 0x61df
movq -0x10(%rbp), %rax
movl $0x1, 0x5ec(%rax)
jmp 0x61df
movq -0x10(%rbp), %rax
movl $0x0, 0x5ec(%rax)
jmp 0x62ba
movq -0x10(%rbp), %rax
cmpl $0x2, 0x5fc(%rax)
jne 0x6231
movq -0x10(%rbp), %rax
movl 0x600(%rax), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x620e
jmp 0x6204
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0x621e
jmp 0x622c
movq -0x10(%rbp), %rax
movl $0x1, 0x600(%rax)
jmp 0x622c
movq -0x10(%rbp), %rax
movl $0x0, 0x600(%rax)
jmp 0x62b8
movq -0x10(%rbp), %rax
cmpl $0x3, 0x5fc(%rax)
jne 0x62b6
movq -0x10(%rbp), %rax
movl 0x5ec(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x625b
jmp 0x6251
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x626b
jmp 0x6279
movq -0x10(%rbp), %rax
movl $0x1, 0x5ec(%rax)
jmp 0x6279
movq -0x10(%rbp), %rax
movl $0x0, 0x5ec(%rax)
movq -0x10(%rbp), %rax
movl 0x600(%rax), %eax
movl %eax, -0x20(%rbp)
testl %eax, %eax
je 0x6296
jmp 0x628c
movl -0x20(%rbp), %eax
subl $0x1, %eax
je 0x62a6
jmp 0x62b4
movq -0x10(%rbp), %rax
movl $0x1, 0x600(%rax)
jmp 0x62b4
movq -0x10(%rbp), %rax
movl $0x0, 0x600(%rax)
jmp 0x62b6
jmp 0x62b8
jmp 0x62ba
jmp 0x62bc
movq -0x10(%rbp), %rdi
callq 0x6490
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/samples/beatclock/beat.cpp
// Function: BeatClock::~BeatClock()
BeatClock::~BeatClock()
{
	timer->Stop();

	StoreConfig();

	DeleteObject(wnd);
	DeleteObject(title);
	DeleteObject(menubar);
	DeleteObject(timer);
	DeleteObject(dragcontrol);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xb115(%rip), %rcx      # 0x116f0
movq %rcx, (%rax)
movq 0x5d8(%rax), %rdi
callq 0x51d0
jmp 0x65ec
movq -0x10(%rbp), %rdi
callq 0x6680
jmp 0x65f7
movq -0x10(%rbp), %rax
movq 0x5b8(%rax), %rdi
callq 0x5490
jmp 0x6609
movq -0x10(%rbp), %rax
movq 0x5c0(%rax), %rdi
callq 0x5490
jmp 0x661b
movq -0x10(%rbp), %rax
movq 0x5c8(%rax), %rdi
callq 0x5490
jmp 0x662d
movq -0x10(%rbp), %rax
movq 0x5d8(%rax), %rdi
callq 0x5490
jmp 0x663f
movq -0x10(%rbp), %rax
movq 0x5d0(%rax), %rdi
callq 0x5490
jmp 0x6651
movq -0x10(%rbp), %rdi
addq $0x608, %rdi            # imm = 0x608
callq 0x54a0
movq -0x10(%rbp), %rdi
callq 0x5290
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x6af0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/samples/beatclock/options.cpp
// Function: Options::OptionsBeats()
Void Options::OptionsBeats()
{
	display_check1->SetText("Show centibeats");
	misc_option1->SetText("Show/hide centibeats");
	alarm_text2->SetText("Internet Beats");
	alarm_edit1->SetText(String::FromInt(Math::Min(999, Time::SecondsToBeats(Time::TimeStringToSeconds(alarm_edit1->GetText())))));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq 0x638(%rax), %rax
movq %rax, -0xa0(%rbp)
leaq 0x2a64(%rip), %rsi      # 0xd213
leaq -0x20(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x5400
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq (%rdi), %rax
movq 0xa0(%rax), %rax
callq *%rax
jmp 0xa7db
leaq -0x20(%rbp), %rdi
callq 0x54a0
movq -0xa8(%rbp), %rax
movq 0x688(%rax), %rax
movq %rax, -0xb8(%rbp)
leaq 0x2a9b(%rip), %rsi      # 0xd29b
leaq -0x48(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x5400
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq (%rdi), %rax
movq 0xa0(%rax), %rax
callq *%rax
jmp 0xa82c
leaq -0x48(%rbp), %rdi
callq 0x54a0
movq -0xa8(%rbp), %rax
movq 0x668(%rax), %rax
movq %rax, -0xc8(%rbp)
leaq 0x29a4(%rip), %rsi      # 0xd1f5
leaq -0x60(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x5400
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq (%rdi), %rax
movq 0xa0(%rax), %rax
callq *%rax
jmp 0xa87d
leaq -0x60(%rbp), %rdi
callq 0x54a0
movq -0xa8(%rbp), %rax
movq 0x660(%rax), %rdi
movq %rdi, -0xe0(%rbp)
movq (%rdi), %rax
movq 0xa8(%rax), %rax
callq *%rax
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x53b0
movq -0xd8(%rbp), %rdi
callq 0xc090
movl %eax, -0xcc(%rbp)
jmp 0xa8d1
movl -0xcc(%rbp), %edi
callq 0xbe00
movl %eax, -0xe4(%rbp)
jmp 0xa8e4
movl -0xe4(%rbp), %esi
movl $0x3e7, %edi            # imm = 0x3E7
callq 0xb440
movl %eax, -0xe8(%rbp)
jmp 0xa8fc
movl -0xe8(%rbp), %eax
movslq %eax, %rsi
leaq -0x78(%rbp), %rdi
callq 0x5160
jmp 0xa910
movq -0xe0(%rbp), %rdi
movq (%rdi), %rax
movq 0xa0(%rax), %rax
leaq -0x78(%rbp), %rsi
callq *%rax
jmp 0xa929
leaq -0x78(%rbp), %rdi
callq 0x54a0
leaq -0x90(%rbp), %rdi
callq 0x54a0
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x54a0
jmp 0xa9bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x54a0
jmp 0xa9bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x54a0
jmp 0xa9bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xa9af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x54a0
leaq -0x90(%rbp), %rdi
callq 0x54a0
movq -0x28(%rbp), %rdi
callq 0x5190
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/samples/beatclock/options.cpp
// Function: Options::OptionsSTF()
Void Options::OptionsSTF()
{
	display_check1->SetText("Show seconds");
	misc_option1->SetText("Show/hide seconds");
	alarm_text2->SetText("Hours/Minutes");
	alarm_edit1->SetText(Time::SecondsToTimeString(Math::Min(86340, Time::BeatsToSeconds(alarm_edit1->GetText().ToInt()))));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x638(%rax), %rax
movq %rax, -0x88(%rbp)
leaq 0x2824(%rip), %rsi      # 0xd223
leaq -0x20(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x5400
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq (%rdi), %rax
movq 0xa0(%rax), %rax
callq *%rax
jmp 0xaa25
leaq -0x20(%rbp), %rdi
callq 0x54a0
movq -0x90(%rbp), %rax
movq 0x688(%rax), %rax
movq %rax, -0xa0(%rbp)
leaq 0x2866(%rip), %rsi      # 0xd2b0
leaq -0x48(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x5400
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq (%rdi), %rax
movq 0xa0(%rax), %rax
callq *%rax
jmp 0xaa76
leaq -0x48(%rbp), %rdi
callq 0x54a0
movq -0x90(%rbp), %rax
movq 0x668(%rax), %rax
movq %rax, -0xb0(%rbp)
leaq 0x27c9(%rip), %rsi      # 0xd264
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x5400
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq (%rdi), %rax
movq 0xa0(%rax), %rax
callq *%rax
jmp 0xaac7
leaq -0x60(%rbp), %rdi
callq 0x54a0
movq -0x90(%rbp), %rax
movq 0x660(%rax), %rdi
movq %rdi, -0xc0(%rbp)
movq (%rdi), %rax
movq 0xa8(%rax), %rax
callq *%rax
movq %rax, %rdi
callq 0x5140
movl %eax, %edi
callq 0xbde0
movl %eax, %esi
movl $0x15144, %edi          # imm = 0x15144
callq 0xb440
movl %eax, %esi
leaq -0x78(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xbe20
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movq (%rdi), %rax
movq 0xa0(%rax), %rax
callq *%rax
jmp 0xab3a
leaq -0x78(%rbp), %rdi
callq 0x54a0
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x54a0
jmp 0xaba6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x54a0
jmp 0xaba6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x54a0
jmp 0xaba6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x54a0
movq -0x28(%rbp), %rdi
callq 0x5190
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/samples/beatclock/options.cpp
// Function: Options::ToggleAlarmState()
Void Options::ToggleAlarmState()
{
	if (isalarm)
	{
		alarm_edit1->Activate();
		alarm_option1->Activate();
		alarm_option2->Activate();
	}
	else
	{
		alarm_edit1->Deactivate();
		alarm_option1->Deactivate();
		alarm_option2->Deactivate();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x6e0(%rax), %rax
testb $0x1, (%rax)
je 0xac05
movq -0x10(%rbp), %rax
movq 0x660(%rax), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq -0x10(%rbp), %rax
movq 0x670(%rax), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq -0x10(%rbp), %rax
movq 0x678(%rax), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
jmp 0xac38
movq -0x10(%rbp), %rax
movq 0x660(%rax), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq -0x10(%rbp), %rax
movq 0x670(%rax), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq -0x10(%rbp), %rax
movq 0x678(%rax), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/samples/beatclock/options.cpp
// Function: Options::OptionsOK()
Void Options::OptionsOK()
{
	if (timeformat == 0)
	{
		alarmbeats = Math::Min(999, (Int) alarm_edit1->GetText().ToInt());
		alarmsecs  = Time::BeatsToSeconds(alarmbeats);
	}
	else
	{
		alarmsecs  = Math::Min(86340, Time::TimeStringToSeconds(alarm_edit1->GetText()));
		alarmbeats = Time::SecondsToBeats(alarmsecs);
	}

	optionsdialog->Close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x6d0(%rax), %rax
cmpl $0x0, (%rax)
jne 0xacb9
movq -0x38(%rbp), %rax
movq 0x660(%rax), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
movq %rax, %rdi
callq 0x5140
movl %eax, %esi
movl $0x3e7, %edi            # imm = 0x3E7
callq 0xb440
movl %eax, %edx
movq -0x38(%rbp), %rax
movq 0x6e8(%rax), %rcx
movl %edx, (%rcx)
movq 0x6e8(%rax), %rax
movl (%rax), %edi
callq 0xbde0
movl %eax, %ecx
movq -0x38(%rbp), %rax
movq 0x6f0(%rax), %rax
movl %ecx, (%rax)
jmp 0xad53
movq -0x38(%rbp), %rax
movq 0x660(%rax), %rdi
movq (%rdi), %rax
movq 0xa8(%rax), %rax
callq *%rax
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x53b0
movq -0x48(%rbp), %rdi
callq 0xc090
movl %eax, -0x3c(%rbp)
jmp 0xacee
movl -0x3c(%rbp), %esi
movl $0x15144, %edi          # imm = 0x15144
callq 0xb440
movl %eax, -0x4c(%rbp)
jmp 0xad00
movq -0x38(%rbp), %rax
movl -0x4c(%rbp), %ecx
movq 0x6f0(%rax), %rax
movl %ecx, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x54a0
movq -0x38(%rbp), %rax
movq 0x6f0(%rax), %rax
movl (%rax), %edi
callq 0xbe00
movl %eax, %ecx
movq -0x38(%rbp), %rax
movq 0x6e8(%rax), %rax
movl %ecx, (%rax)
jmp 0xad53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x54a0
jmp 0xad69
movq -0x38(%rbp), %rax
movq 0x5e8(%rax), %rdi
callq 0x5430
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5190
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/samples/beatclock/options.cpp
// Function: Options::OptionsCancel()
Void Options::OptionsCancel()
{
	timeformat  = oldtf;
	centi	     = oldct;
	modechange  = oldmc;
	timezone    = oldtz;
	isalarm     = oldia;
	alarmbeats  = oldab;
	alarmsecs   = oldas;
	alarmtext   = oldat;
	alarmoption = oldao;

	optionsdialog->Close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x718(%rax), %edx
movq 0x6d0(%rax), %rcx
movl %edx, (%rcx)
movb 0x71c(%rax), %dl
movq 0x6d8(%rax), %rcx
andb $0x1, %dl
movb %dl, (%rcx)
movl 0x720(%rax), %edx
movq 0x6f8(%rax), %rcx
movl %edx, (%rcx)
movl 0x724(%rax), %edx
movq 0x700(%rax), %rcx
movl %edx, (%rcx)
movb 0x728(%rax), %dl
movq 0x6e0(%rax), %rcx
andb $0x1, %dl
movb %dl, (%rcx)
movl 0x72c(%rax), %edx
movq 0x6e8(%rax), %rcx
movl %edx, (%rcx)
movl 0x730(%rax), %edx
movq 0x6f0(%rax), %rcx
movl %edx, (%rcx)
movq %rax, %rsi
addq $0x738, %rsi            # imm = 0x738
movq 0x708(%rax), %rdi
callq 0x52f0
movq -0x10(%rbp), %rax
movl 0x750(%rax), %edx
movq 0x710(%rax), %rcx
movl %edx, (%rcx)
movq 0x5e8(%rax), %rdi
callq 0x5430
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/samples/beatclock/../../include/smooth/templates/signals/signal.h
// Function: int smooth::Signal0<void>::Connect<void>(smooth::Signal0<void>*)
Int Connect(SIGNALS_SIGNAL_CLASS_NAME<slotReturnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES> *sig)
			{
				if ((Signal *) sig == (Signal *) this) return Error();

				if (slotsN == NIL)
				{
					slotsN = new Array<Void *>();
					slotsN->EnableLocking();
				}

				slotsN->Add(new SIGNALS_SLOT_SIGNAL_CLASS_NAME<slotReturnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES>(sig));

				return Success();
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0xb2d6
leaq -0x28(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7090
leaq -0x28(%rbp), %rdi
callq 0x7050
movl %eax, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x70c0
jmp 0xb3ae
movq -0x58(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xb332
movl $0x58, %edi
callq 0x52e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x7120
jmp 0xb2fc
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0x51b0
jmp 0xb332
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x58, %esi
callq 0x5050
jmp 0xb3b7
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x70(%rbp)
movl $0x10, %edi
callq 0x52e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rsi
callq 0xbac0
jmp 0xb35d
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x7160
leaq -0x50(%rbp), %rdi
callq 0x7010
leaq -0x50(%rbp), %rdi
callq 0x7050
movl %eax, -0x4(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7070
jmp 0xb3ae
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x10, %esi
callq 0x5050
jmp 0xb3b7
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5190
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/samples/beatclock/time.cpp
// Function: Time::GetDayOfWeek(int, int, int)
Int Time::GetDayOfWeek(Int day, Int month, Int year)
{
	month += 10;
	year   = (month - 24) / 12 + year;
	day    = (((13 * (month - (month / 13) * 12) - 1) / 5 + day + 77 + 5 * (year - (year / 100) * 100) / 4 + year / 400 - (year / 100) * 2) % 7);

	return day;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x8(%rbp), %eax
addl $0xa, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
subl $0x18, %eax
movl $0xc, %ecx
cltd
idivl %ecx
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl $0xd, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x20(%rbp), %eax
imull $0xc, %ecx, %ecx
subl %ecx, %eax
imull $0xd, %eax, %eax
subl $0x1, %eax
movl $0x5, %ecx
cltd
idivl %ecx
addl -0x4(%rbp), %eax
addl $0x4d, %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x1c(%rbp), %eax
imull $0x64, %ecx, %ecx
subl %ecx, %eax
imull $0x5, %eax, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x18(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x10(%rbp), %eax
shll %ecx
subl %ecx, %eax
movl $0x7, %ecx
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/samples/beatclock/time.cpp
// Function: Time::OutOfMonth(int, int, int)
Bool Time::OutOfMonth(Int day, Int month, Int year)
{
	if	(day > 31									  ) return True;
	else if (day > 30 && (month == 4 || month == 6 || month == 9 || month == 11)		  ) return True;
	else if (day > 29 && month == 2								  ) return True;
	else if (day > 28 && month == 2 && (year % 4 != 0 || (year % 100 == 0 && year % 400 != 0))) return True;

	return False;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x1f, -0x8(%rbp)
jle 0xc2bc
movb $0x1, -0x1(%rbp)
jmp 0xc33e
cmpl $0x1e, -0x8(%rbp)
jle 0xc2e0
cmpl $0x4, -0xc(%rbp)
je 0xc2da
cmpl $0x6, -0xc(%rbp)
je 0xc2da
cmpl $0x9, -0xc(%rbp)
je 0xc2da
cmpl $0xb, -0xc(%rbp)
jne 0xc2e0
movb $0x1, -0x1(%rbp)
jmp 0xc33e
cmpl $0x1d, -0x8(%rbp)
jle 0xc2f2
cmpl $0x2, -0xc(%rbp)
jne 0xc2f2
movb $0x1, -0x1(%rbp)
jmp 0xc33e
cmpl $0x1c, -0x8(%rbp)
jle 0xc334
cmpl $0x2, -0xc(%rbp)
jne 0xc334
movl -0x10(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xc32e
movl -0x10(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xc334
movl -0x10(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
cmpl $0x0, %edx
je 0xc334
movb $0x1, -0x1(%rbp)
jmp 0xc33e
jmp 0xc336
jmp 0xc338
jmp 0xc33a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/joewalnes[P]verifysignature/example.c
// Function: main
int main() {

    const char *public_key = "bdb9bfb228870f53d3f11272efd6747b7e413935fb61754d65cf74b57f0ca29f";
    const char *signature = "ff72e41634cf372e42cdda9413c1f18308ff9f745326d34af97c4036fb7f927f97e08b12920abd3f16c0ec40615ce8532e2aeea2acaca49326f6acb3c6941e00";

    const unsigned char *message = (const unsigned char *) "hello world\n";
    size_t message_len = 12;

    int result = verify_signature(public_key, signature, message, message_len);

    if (result != 0) {
        fprintf(stderr, "Signature verification failed!\n");
        return 1;
    } else {
        printf("ok\n");
        return 0;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xde5e(%rip), %rax      # 0xf004
movq %rax, -0x10(%rbp)
leaq 0xde94(%rip), %rax      # 0xf045
movq %rax, -0x18(%rbp)
leaq 0xdf0a(%rip), %rax      # 0xf0c6
movq %rax, -0x20(%rbp)
movq $0xc, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1230
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x1207
movq 0xfe0b(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0xdedc(%rip), %rsi      # 0xf0d3
movb $0x0, %al
callq 0x1070
movl $0x1, -0x4(%rbp)
jmp 0x121c
leaq 0xdee5(%rip), %rdi      # 0xf0f3
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/joewalnes[P]verifysignature/verifysignature.c
// Function: verify_signature
int verify_signature(const char *public_key_hex,
                     const char *signature_hex,
                     const unsigned char *contents,
                     const size_t contents_len) {
    int pk_len = crypto_sign_PUBLICKEYBYTES;
    int sig_len = crypto_sign_BYTES;
    unsigned char pk[pk_len];
    unsigned char sig[sig_len];

    hex2bin(pk, pk_len, public_key_hex, strlen(public_key_hex));
    hex2bin(sig, sig_len, signature_hex, strlen(signature_hex));

    return verify(sig, contents, contents_len, pk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x20, -0x24(%rbp)
movl $0x40, -0x28(%rbp)
movl -0x24(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x30(%rbp)
movq %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x48(%rbp)
movq %rcx, %rsp
movq %rax, -0x38(%rbp)
movl -0x28(%rbp), %eax
movq %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x50(%rbp)
movq %rcx, %rsp
movq %rax, -0x40(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1030
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq %rax, %rcx
callq 0x1320
movslq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rdi
movq %rax, %rcx
callq 0x1320
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rcx
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1460
movq -0x30(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joewalnes[P]verifysignature/verifysignature.c
// Function: hex2bin
int hex2bin(unsigned char * const bin, const size_t bin_maxlen,
            const char * const hex, const size_t hex_len) {
    size_t        bin_pos = (size_t) 0U;
    size_t        hex_pos = (size_t) 0U;
    int           ret = 0;
    unsigned char c;
    unsigned char c_acc = 0U;
    unsigned char c_alpha0, c_alpha;
    unsigned char c_num0, c_num;
    unsigned char c_val;
    unsigned char state = 0U;

    while (hex_pos < hex_len) {
        c = (unsigned char) hex[hex_pos];
        c_num = c ^ 48U;
        c_num0 = (c_num - 10U) >> 8;
        c_alpha = (c & ~32U) - 55U;
        c_alpha0 = ((c_alpha - 10U) ^ (c_alpha - 16U)) >> 8;
        if ((c_num0 | c_alpha0) == 0U) {
            break;
        }
        c_val = (c_num0 & c_num) | (c_alpha0 & c_alpha);
        if (bin_pos >= bin_maxlen) {
            ret = -1;
            break;
        }
        if (state == 0U) {
            c_acc = c_val * 16U;
        } else {
            bin[bin_pos++] = c_acc | c_val;
        }
        state = ~state;
        hex_pos++;
    }
    if (state != 0U) {
        hex_pos--;
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movb $0x0, -0x36(%rbp)
movb $0x0, -0x3c(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x1438
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x35(%rbp)
movzbl -0x35(%rbp), %eax
xorl $0x30, %eax
movb %al, -0x3a(%rbp)
movzbl -0x3a(%rbp), %eax
subl $0xa, %eax
shrl $0x8, %eax
movb %al, -0x39(%rbp)
movzbl -0x35(%rbp), %eax
andl $-0x21, %eax
subl $0x37, %eax
movb %al, -0x38(%rbp)
movzbl -0x38(%rbp), %eax
subl $0xa, %eax
movzbl -0x38(%rbp), %ecx
subl $0x10, %ecx
xorl %ecx, %eax
shrl $0x8, %eax
movb %al, -0x37(%rbp)
movzbl -0x39(%rbp), %eax
movzbl -0x37(%rbp), %ecx
orl %ecx, %eax
cmpl $0x0, %eax
jne 0x13ba
jmp 0x1438
movzbl -0x39(%rbp), %eax
movzbl -0x3a(%rbp), %ecx
andl %ecx, %eax
movzbl -0x37(%rbp), %ecx
movzbl -0x38(%rbp), %edx
andl %edx, %ecx
orl %ecx, %eax
movb %al, -0x3b(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x13e6
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
jmp 0x1438
movzbl -0x3c(%rbp), %eax
cmpl $0x0, %eax
jne 0x13fb
movzbl -0x3b(%rbp), %eax
shll $0x4, %eax
movb %al, -0x36(%rbp)
jmp 0x141d
movzbl -0x36(%rbp), %eax
movzbl -0x3b(%rbp), %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movb %dl, (%rax,%rcx)
movzbl -0x3c(%rbp), %eax
xorl $-0x1, %eax
movb %al, -0x3c(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1353
movzbl -0x3c(%rbp), %eax
cmpl $0x0, %eax
je 0x144d
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joewalnes[P]verifysignature/verifysignature.c
// Function: verify
int verify(const unsigned char *sig, const unsigned char *m,
           unsigned long long mlen, const unsigned char *pk) {
    hash_sha512_state hs;
    unsigned char h[64];
    unsigned char rcheck[32];
    unsigned int  i;
    unsigned char d = 0;
    ge_p3 A;
    ge_p2 R;

    if (sig[63] & 224) {
        return -1;
    }
    if (ge_frombytes_negate_vartime(&A, pk) != 0) {
        return -1;
    }
    for (i = 0; i < 32; ++i) {
        d |= pk[i];
    }
    if (d == 0) {
        return -1;
    }

    hash_sha512_init(&hs);
    hash_sha512_update(&hs, sig, 32);
    hash_sha512_update(&hs, pk, 32);
    hash_sha512_update(&hs, m, mlen);
    hash_sha512_final(&hs, h);
    sc_reduce(h);

    ge_double_scalarmult_vartime(&R, h, &A, sig + 32);
    ge_tobytes(rcheck, &R);

    return verify_32(rcheck, sig) | (-(rcheck == sig)) |
           memcmp(sig, rcheck, 32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movb $0x0, -0x165(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x3f(%rax), %eax
andl $0xe0, %eax
cmpl $0x0, %eax
je 0x14a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x160a
movq -0x28(%rbp), %rsi
leaq -0x208(%rbp), %rdi
callq 0x1620
cmpl $0x0, %eax
je 0x14c1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x160a
movl $0x0, -0x164(%rbp)
cmpl $0x20, -0x164(%rbp)
jae 0x1502
movq -0x28(%rbp), %rax
movl -0x164(%rbp), %ecx
movzbl (%rax,%rcx), %ecx
movzbl -0x165(%rbp), %eax
orl %ecx, %eax
movb %al, -0x165(%rbp)
movl -0x164(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x164(%rbp)
jmp 0x14cb
movzbl -0x165(%rbp), %eax
cmpl $0x0, %eax
jne 0x151a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x160a
leaq -0xf8(%rbp), %rdi
callq 0x1810
movq -0x10(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
movl $0x20, %edx
callq 0x18d0
movq -0x28(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
movl $0x20, %edx
callq 0x18d0
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0xf8(%rbp), %rdi
callq 0x18d0
leaq -0x140(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
callq 0x1a30
leaq -0x140(%rbp), %rdi
callq 0x1a80
leaq -0x140(%rbp), %rsi
movq -0x10(%rbp), %rcx
addq $0x20, %rcx
leaq -0x280(%rbp), %rdi
leaq -0x208(%rbp), %rdx
callq 0x3010
leaq -0x160(%rbp), %rdi
leaq -0x280(%rbp), %rsi
callq 0x34e0
leaq -0x160(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3570
leaq -0x160(%rbp), %rcx
cmpq -0x10(%rbp), %rcx
sete %cl
andb $0x1, %cl
movzbl %cl, %edx
xorl %ecx, %ecx
subl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x284(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x160(%rbp), %rsi
movl $0x20, %edx
callq 0x1060
movl %eax, %ecx
movl -0x284(%rbp), %eax
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joewalnes[P]verifysignature/verifysignature.c
// Function: hash_sha512_init
void hash_sha512_init(hash_sha512_state *state) {
    state->count[0] = state->count[1] = 0;
    state->state[0] = 0x6a09e667f3bcc908ULL;
    state->state[1] = 0xbb67ae8584caa73bULL;
    state->state[2] = 0x3c6ef372fe94f82bULL;
    state->state[3] = 0xa54ff53a5f1d36f1ULL;
    state->state[4] = 0x510e527fade682d1ULL;
    state->state[5] = 0x9b05688c2b3e6c1fULL;
    state->state[6] = 0x1f83d9abfb41bd6bULL;
    state->state[7] = 0x5be0cd19137e2179ULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movabsq $0x6a09e667f3bcc908, %rcx # imm = 0x6A09E667F3BCC908
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movabsq $-0x4498517a7b3558c5, %rcx # imm = 0xBB67AE8584CAA73B
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movabsq $0x3c6ef372fe94f82b, %rcx # imm = 0x3C6EF372FE94F82B
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movabsq $-0x5ab00ac5a0e2c90f, %rcx # imm = 0xA54FF53A5F1D36F1
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movabsq $0x510e527fade682d1, %rcx # imm = 0x510E527FADE682D1
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movabsq $-0x64fa9773d4c193e1, %rcx # imm = 0x9B05688C2B3E6C1F
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movabsq $0x1f83d9abfb41bd6b, %rcx # imm = 0x1F83D9ABFB41BD6B
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movabsq $0x5be0cd19137e2179, %rcx # imm = 0x5BE0CD19137E2179
movq %rcx, 0x38(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joewalnes[P]verifysignature/verifysignature.c
// Function: hash_sha512_update
void hash_sha512_update(hash_sha512_state *state,
                        const unsigned char *in,
                        unsigned long long inlen) {
    uint64_t bitlen[2];
    uint64_t r;
    const unsigned char *src = in;

    r = (state->count[1] >> 3) & 0x7f;

    bitlen[1] = ((uint64_t)inlen) << 3;
    bitlen[0] = ((uint64_t)inlen) >> 61;

    /* LCOV_EXCL_START */
    if ((state->count[1] += bitlen[1]) < bitlen[1]) {
        state->count[0]++;
    }
    /* LCOV_EXCL_STOP */
    state->count[0] += bitlen[0];

    if (inlen < 128 - r) {
        memcpy(&state->buf[r], src, inlen);
        return;
    }
    memcpy(&state->buf[r], src, 128 - r);
    sha512_transform(state->state, state->buf);
    src += 128 - r;
    inlen -= 128 - r;

    while (inlen >= 128) {
        sha512_transform(state->state, src);
        src += 128;
        inlen -= 128;
    }
    memcpy(state->buf, src, inlen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
shrq $0x3, %rax
andq $0x7f, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
shrq $0x3d, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
addq 0x48(%rcx), %rax
movq %rax, 0x48(%rcx)
cmpq -0x28(%rbp), %rax
jae 0x193e
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rax
movl $0x80, %ecx
subq -0x38(%rbp), %rcx
cmpq %rcx, %rax
jae 0x197e
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
addq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1080
jmp 0x1a1c
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
addq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl $0x80, %edx
subq -0x38(%rbp), %rdx
callq 0x1080
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x50, %rsi
callq 0x38a0
movl $0x80, %eax
subq -0x38(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x80, %ecx
subq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpq $0x80, -0x18(%rbp)
jb 0x1a07
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x38a0
movq -0x40(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
subq $0x80, %rax
movq %rax, -0x18(%rbp)
jmp 0x19d2
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1080
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joewalnes[P]verifysignature/verifysignature.c
// Function: ge_tobytes
void ge_tobytes(unsigned char *s, const ge_p2 *h) {
    fe recip;
    fe x;
    fe y;

    fe_invert(recip,h->Z);
    fe_mul(x,h->X,recip);
    fe_mul(y,h->Y,recip);
    fe_tobytes(s,y);
    s[31] ^= fe_isnegative(x) << 7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
callq 0xd520
leaq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0xb2f0
leaq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
leaq -0x40(%rbp), %rdx
callq 0xb2f0
movq -0x8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xd8c0
leaq -0x70(%rbp), %rdi
callq 0xca60
movl %eax, %edx
shll $0x7, %edx
movq -0x8(%rbp), %rax
movzbl 0x1f(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x1f(%rax)
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joewalnes[P]verifysignature/verifysignature.c
// Function: sha512_pad
void sha512_pad(hash_sha512_state *state) {
    unsigned char len[16];
    uint64_t r, plen;

    be64enc_vect(len, state->count, 16);

    r = (state->count[1] >> 3) & 0x7f;
    plen = (r < 112) ? (112 - r) : (240 - r);
    hash_sha512_update(state, PAD, (unsigned long long) plen);

    hash_sha512_update(state, len, 16);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x40, %rsi
movl $0x10, %edx
callq 0xa130
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
shrq $0x3, %rax
andq $0x7f, %rax
movq %rax, -0x28(%rbp)
cmpq $0x70, -0x28(%rbp)
jae 0xa0ec
movl $0x70, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xa0f9
movl $0xf0, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x7310(%rip), %rsi      # 0x11420
callq 0x18d0
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x18d0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/joewalnes[P]verifysignature/verifysignature.c
// Function: load_3
uint64_t load_3(const unsigned char *in) {
    uint64_t result;
    result = (uint64_t) in[0];
    result |= ((uint64_t) in[1]) << 8;
    result |= ((uint64_t) in[2]) << 16;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
shlq $0x8, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x2(%rax), %eax
shlq $0x10, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joewalnes[P]verifysignature/verifysignature.c
// Function: load_4
uint64_t load_4(const unsigned char *in) {
    uint64_t result;
    result = (uint64_t) in[0];
    result |= ((uint64_t) in[1]) << 8;
    result |= ((uint64_t) in[2]) << 16;
    result |= ((uint64_t) in[3]) << 24;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
shlq $0x8, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x2(%rax), %eax
shlq $0x10, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x3(%rax), %eax
shlq $0x18, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joewalnes[P]verifysignature/verifysignature.c
// Function: be64dec
uint64_t be64dec(const void *pp) {
    const uint8_t *p = (uint8_t const *)pp;

    return ((uint64_t)(p[7]) + ((uint64_t)(p[6]) << 8) +
            ((uint64_t)(p[5]) << 16) + ((uint64_t)(p[4]) << 24) +
            ((uint64_t)(p[3]) << 32) + ((uint64_t)(p[2]) << 40) +
            ((uint64_t)(p[1]) << 48) + ((uint64_t)(p[0]) << 56));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x7(%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x6(%rcx), %ecx
shlq $0x8, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
shlq $0x10, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
shlq $0x18, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shlq $0x20, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shlq $0x28, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shlq $0x30, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
shlq $0x38, %rcx
addq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joewalnes[P]verifysignature/verifysignature.c
// Function: fe_1
void fe_1(fe h) {
    h[0] = 1;
    h[1] = 0;
    h[2] = 0;
    h[3] = 0;
    h[4] = 0;
    h[5] = 0;
    h[6] = 0;
    h[7] = 0;
    h[8] = 0;
    h[9] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%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)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
popq %rbp
retq
nopw (%rax,%rax)