LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_str.c
// Function: fin_str_concat
fin_str_t* fin_str_concat(fin_ctx_t* ctx, fin_str_t* a, fin_str_t* b) {
    char* buffer = ctx->alloc(NULL, a->len + b->len + 1);
    strncpy(buffer, a->cstr, a->len);
    strncpy(buffer + a->len, b->cstr, b->len);
    buffer[a->len + b->len] = '\0';
    fin_str_t* result = fin_str_create(ctx, buffer, a->len + b->len);
    ctx->alloc(buffer, 0);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %esi
movq -0x18(%rbp), %rcx
addl 0x4(%rcx), %esi
addl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %edi
callq *%rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xc, %rsi
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rdx
callq 0x3070
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
addq $0xc, %rsi
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rdx
callq 0x3070
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq -0x18(%rbp), %rdx
addl 0x4(%rdx), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x18(%rbp), %rax
addl 0x4(%rax), %edx
callq 0xae20
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq *%rax
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_str.c
// Function: fin_str_join
fin_str_t* fin_str_join(fin_ctx_t* ctx, fin_str_t* arr, int32_t count) {
    int32_t length = 0;
    for (int32_t i=0; i<count; i++)
        length += fin_str_len(arr + i);
    char* buffer = ctx->alloc(NULL, length + 1);
    length = 0;
    for (int32_t i=0; i<count; i++) {
        if (!(arr+i))
            continue;
        strncpy(buffer, (arr+i)->cstr, (arr+i)->len);
        length += (arr+i)->len;
    }
    fin_str_t* result = fin_str_create(ctx, buffer, length);
    ctx->alloc(buffer, 0);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xb26e
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0xb340
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb241
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x18(%rbp), %esi
addl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %edi
callq *%rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xb304
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, %rax
jne 0xb2b2
jmp 0xb2f9
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x2c(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
addq $0xc, %rsi
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0x4(%rax), %rdx
callq 0x3070
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb293
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0xae20
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq *%rax
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_vm.c
// Function: fin_vm_invoke_int
inline void fin_vm_invoke_int(fin_ctx_t* ctx, fin_mod_func_t* func, fin_val_t* stack) {
    if (func->is_native) {
        fin_val_t result;
        (*func->func)(ctx, stack - func->args, &result);
        if (func->ret_type)
            stack[-func->args] = result;
    }
    else
        fin_vm_interpret(ctx, func, stack);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0xba53
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
movzbl 0x34(%rcx), %ecx
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rsi
leaq -0x20(%rbp), %rdx
callq *%rax
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xba51
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x34(%rcx), %edx
xorl %ecx, %ecx
subl %edx, %ecx
movslq %ecx, %rcx
movq -0x20(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0xba64
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xb3a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_vm.c
// Function: fin_vm_create
fin_vm_t* fin_vm_create(fin_ctx_t* ctx) {
    fin_vm_t* vm = (fin_vm_t*)ctx->alloc(NULL, sizeof(fin_vm_t));
    vm->stack.top   = vm->stack.storage;
    vm->stack.begin = vm->stack.storage;
    vm->stack.end   = vm->stack.storage + FIN_COUNT_OF(vm->stack.storage);
    vm->ctx = ctx;
    return vm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x220, %esi            # imm = 0x220
callq *(%rax)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
addq $0x18, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
addq $0x18, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
addq $0x18, %rcx
addq $0x200, %rcx            # imm = 0x200
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x218(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/mod/fin_io.c
// Function: fin_io_file_write
static void fin_io_file_write(fin_ctx_t* ctx, const fin_val_t* args, fin_val_t* ret) {
    const char* file = fin_str_cstr(args[0].s);
    if (!file)
        return;
    FILE* fp = fopen(file, "wb");
    if (!fp)
        return;
    fputs(fin_str_cstr(args[1].s), fp);
    fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xb370
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xbc6d
jmp 0xbcac
movq -0x20(%rbp), %rdi
leaq 0x1e66(%rip), %rsi      # 0xdade
callq 0x3240
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xbc8a
jmp 0xbcac
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xb370
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x3120
movq -0x28(%rbp), %rdi
callq 0x30e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/test-show-type.c
// Function: main
int main(int argc, char **argv)
{
	struct string_list *filelist = NULL;
	char *file;

	sparse_initialize(argc, argv, &filelist);
	Wdecl = 0;
	FOR_EACH_PTR(filelist, file) {
		show_symbols(sparse(file));
	} END_FOR_EACH_PTR(file);

	return has_error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x11d60
leaq 0x72da3(%rip), %rax     # 0x84208
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1148c
jmp 0x11509
jmp 0x1148e
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x30(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x114f5
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x114d9
cmpq $0x0, -0x20(%rbp)
jne 0x114d9
jmp 0x114ea
movq -0x20(%rbp), %rdi
callq 0x121d0
movq %rax, %rdi
callq 0x11520
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x11495
jmp 0x114f7
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x1148e
leaq 0x7a864(%rip), %rax     # 0x8bd74
movl (%rax), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/test-show-type.c
// Function: show_symbols
static void show_symbols(struct symbol_list *list)
{
	struct symbol *sym;

	FOR_EACH_PTR(list, sym) {
		printf("%s;\n", show_typename(sym));
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11550
jmp 0x115da
jmp 0x11552
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x115c2
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x1159d
cmpq $0x0, -0x10(%rbp)
jne 0x1159d
jmp 0x115b7
movq -0x10(%rbp), %rdi
callq 0x24b40
movq %rax, %rsi
leaq 0x50a54(%rip), %rdi     # 0x62004
movb $0x0, %al
callq 0x110f0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x11559
jmp 0x115c4
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x11552
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: reverse
uint32_t reverse (uint8_t *data, uint32_t l)
{
    uint8_t t;
    l--;
    for (uint32_t i=0; i <= l/2; i++)
    {
        t = data[i];
        data[i] = data[l - i];
        data[l - i] = t;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
shrl %ecx
cmpl %ecx, %eax
ja 0x374a
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl -0x14(%rbp), %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movb %dl, (%rax,%rcx)
movb -0xd(%rbp), %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl -0x14(%rbp), %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x36fb
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: ike_hdr2char
uint32_t ike_hdr2char (ike_header *hdr, uint8_t *buf)
{
    uint32_t length = hdr->length;
    reverse ((uint8_t*)&hdr->init_SPI, sizeof (hdr->init_SPI));
    reverse ((uint8_t*)&hdr->resp_SPI, sizeof (hdr->resp_SPI));
    reverse ((uint8_t*)&hdr->message_ID, sizeof (hdr->message_ID));
    reverse ((uint8_t*)&hdr->length, sizeof (hdr->length));
    memcpy (buf, hdr, length);
    reverse ((uint8_t*)&hdr->init_SPI, sizeof (hdr->init_SPI));
    reverse ((uint8_t*)&hdr->resp_SPI, sizeof (hdr->resp_SPI));
    reverse ((uint8_t*)&hdr->message_ID, sizeof (hdr->message_ID));
    reverse ((uint8_t*)&hdr->length, sizeof (hdr->length));
    return sizeof (*hdr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x3050
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movl $0x8, %esi
callq 0x3050
movq -0x8(%rbp), %rdi
addq $0x14, %rdi
movl $0x4, %esi
callq 0x3050
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movl $0x4, %esi
callq 0x3050
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x32c0
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x3050
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movl $0x8, %esi
callq 0x3050
movq -0x8(%rbp), %rdi
addq $0x14, %rdi
movl $0x4, %esi
callq 0x3050
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movl $0x4, %esi
callq 0x3050
movl $0x1c, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: gen_pl_hdr2char
uint32_t gen_pl_hdr2char (generic_payload_header *hdr, uint8_t *buf)
{
    uint32_t length = hdr->payload_length;
    reverse ((uint8_t*)&hdr->payload_length, sizeof (hdr->payload_length));
    memcpy (buf, hdr, length);
    reverse ((uint8_t*)&hdr->payload_length, sizeof (hdr->payload_length));
    return sizeof (*hdr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
movl $0x2, %esi
callq 0x3050
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x32c0
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
movl $0x2, %esi
callq 0x3050
movl $0x4, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: char2gen_pl_hdr
uint32_t char2gen_pl_hdr (uint8_t *buf, generic_payload_header *hdr)
{
    uint32_t offset = 0;
    CPY (buf, offset, hdr->next_payload);
    CPY (buf, offset, hdr->critical);
    CPY (buf, offset, hdr->payload_length);
    return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
movl $0x1, %esi
callq 0x3050
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl -0x14(%rbp), %edx
movb (%rcx,%rdx), %cl
movb %cl, (%rax)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
movl $0x1, %esi
callq 0x3050
movl -0x14(%rbp), %eax
addq $0x1, %rax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
movl $0x1, %esi
callq 0x3050
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl -0x14(%rbp), %edx
movb (%rcx,%rdx), %cl
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
movl $0x1, %esi
callq 0x3050
movl -0x14(%rbp), %eax
addq $0x1, %rax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
movl $0x2, %esi
callq 0x3050
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl -0x14(%rbp), %edx
movw (%rcx,%rdx), %cx
movw %cx, 0x2(%rax)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
movl $0x2, %esi
callq 0x3050
movl -0x14(%rbp), %eax
addq $0x2, %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: transform2char
uint32_t transform2char (transform *trans, uint8_t *buf)
{
    uint32_t length = trans->transform_length;
    reverse ((uint8_t*) &trans->transform_length, sizeof (trans->transform_length));
    reverse ((uint8_t*) &trans->transform_ID, sizeof (trans->transform_ID));
    if (length == 8)
        memcpy (buf, trans, length);
    else
    {
        if (trans->attribute_format >> 7)
        {
            memcpy (buf, trans, 10);
            memcpy (buf+10, trans->attribute_value, 2);
        }
        else
        {   
            memcpy (buf, trans, 10);
            memcpy (buf+10, trans->attribute_value,
                2+((trans->attribute_value[0] << 8)+trans->attribute_value[1]));
        }
    }
    reverse ((uint8_t*) &trans->transform_length, sizeof (trans->transform_length));
    reverse ((uint8_t*) &trans->transform_ID, sizeof (trans->transform_ID));
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
movl $0x2, %esi
callq 0x3050
movq -0x8(%rbp), %rdi
addq $0x6, %rdi
movl $0x2, %esi
callq 0x3050
cmpl $0x8, -0x14(%rbp)
jne 0x3bfc
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x32c0
jmp 0x3c86
movq -0x8(%rbp), %rax
movzbl 0x8(%rax), %eax
sarl $0x7, %eax
cmpl $0x0, %eax
je 0x3c37
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movw 0x8(%rcx), %cx
movw %cx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0xa(%rcx), %rcx
movw (%rcx), %cx
movw %cx, 0xa(%rax)
jmp 0x3c84
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movw 0x8(%rcx), %cx
movw %cx, 0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0xa, %rdi
movq -0x8(%rbp), %rax
movq 0xa(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0xa(%rax), %rax
movzbl (%rax), %eax
shll $0x8, %eax
movq -0x8(%rbp), %rcx
movq 0xa(%rcx), %rcx
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
addl $0x2, %eax
movslq %eax, %rdx
callq 0x32c0
jmp 0x3c86
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
movl $0x2, %esi
callq 0x3050
movq -0x8(%rbp), %rdi
addq $0x6, %rdi
movl $0x2, %esi
callq 0x3050
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: proposal2char
uint32_t proposal2char (proposal *prop, uint8_t *buf)
{
    uint32_t offset = 0;
    uint32_t length = prop->proposal_length;
    reverse ((uint8_t*)&prop->proposal_length, sizeof (prop->proposal_length));
    if (prop->SPI_size > 0) reverse ((uint8_t*)prop->SPI, prop->SPI_size);
    memcpy (buf, prop, 8);
    offset += 8;
    memcpy (buf+8, prop->SPI, prop->SPI_size);
    offset += prop->SPI_size;
    for (uint32_t i = 0; i < prop->num_transforms; i++)
        offset += transform2char ((prop->transforms)+i, buf+offset);
    reverse ((uint8_t*)&prop->proposal_length, sizeof (prop->proposal_length));
    if (prop->SPI_size > 0) reverse ((uint8_t*)prop->SPI, prop->SPI_size);
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
movl $0x2, %esi
callq 0x3050
movq -0x8(%rbp), %rax
movzbl 0x6(%rax), %eax
cmpl $0x0, %eax
jle 0x4066
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movzbl 0x6(%rax), %esi
callq 0x3050
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movzbl 0x6(%rax), %eax
movl %eax, %edx
callq 0x32c0
movq -0x8(%rbp), %rax
movzbl 0x6(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
cmpl %ecx, %eax
jae 0x40f2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x1c(%rbp), %eax
imulq $0x12, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
addq %rax, %rsi
callq 0x34b0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x40b1
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
movl $0x2, %esi
callq 0x3050
movq -0x8(%rbp), %rax
movzbl 0x6(%rax), %eax
cmpl $0x0, %eax
jle 0x4126
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movzbl 0x6(%rax), %esi
callq 0x3050
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: sa_pl2char
uint32_t sa_pl2char (SA_payload *pl, uint8_t *buf)
{
    uint32_t offset = gen_pl_hdr2char (&pl->header, buf);
    uint32_t length = pl->header.payload_length;
    uint32_t prop_num = 1;
    if (sizeof (pl->header) < length)
        do
        {
            offset += proposal2char (pl->proposals + prop_num-1, buf+offset);
            prop_num++;
        } while (pl->proposals[prop_num-2].more == 2);
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x30a0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, %ecx
movl $0x4, %eax
cmpq %rcx, %rax
jae 0x4508
jmp 0x44b3
movq -0x8(%rbp), %rax
movq 0x4(%rax), %rdi
movl -0x1c(%rbp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rdi
addq $-0x18, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
addq %rax, %rsi
callq 0x33b0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x4(%rax), %rax
movl -0x1c(%rbp), %ecx
subl $0x2, %ecx
movl %ecx, %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x44b3
jmp 0x4508
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: char2sa_pl
uint32_t char2sa_pl (uint8_t *buf, SA_payload *pl)
{
    uint32_t offset = char2gen_pl_hdr (buf, &pl->header);
    pl->proposals = calloc (pl->header.payload_length - offset, 1);
    MEMCHECK (pl->proposals);
    uint32_t i = 0;
    do
    {
        offset += char2proposal (buf+offset, pl->proposals+i);
        i++;
    } while ((pl->proposals+i-1)->more != 0);
    return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3510
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %eax
subl -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x3250
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x4(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x4(%rax)
jne 0x4598
movq 0xda82(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x8af8(%rip), %rsi      # 0xd078
leaq 0x8af5(%rip), %rdx      # 0xd07c
movb $0x0, %al
callq 0x3270
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x34c0
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x4(%rax), %rsi
movl -0x18(%rbp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rsi
callq 0x31e0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x4(%rax), %rax
movl -0x18(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movzbl -0x18(%rax), %eax
cmpl $0x0, %eax
jne 0x459f
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: ke_pl2char
uint32_t ke_pl2char (key_exchange_payload *pl, uint8_t *buf)
{
    uint32_t length = pl->header.payload_length;
    uint32_t offset = gen_pl_hdr2char (&pl->header, buf);
    uint16_t tmp_l = sizeof (pl->dh_group_num) + sizeof (pl->reserved);
    reverse ((uint8_t*)&pl->dh_group_num, sizeof (pl->dh_group_num));
    memcpy (buf+offset, &pl->dh_group_num, tmp_l);
    offset += tmp_l;
    tmp_l = length - tmp_l - sizeof (pl->header);
    memcpy (buf+offset, pl->key_exchange_data, tmp_l);
    offset += tmp_l;
    reverse ((uint8_t*)&pl->dh_group_num, sizeof (pl->dh_group_num));
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x30a0
movl %eax, -0x18(%rbp)
movw $0x4, -0x1a(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movl $0x2, %esi
callq 0x3050
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x4, %rsi
movzwl -0x1a(%rbp), %eax
movl %eax, %edx
callq 0x32c0
movzwl -0x1a(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movzwl -0x1a(%rbp), %ecx
subl %ecx, %eax
movl %eax, %eax
subq $0x4, %rax
movw %ax, -0x1a(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movzwl -0x1a(%rbp), %eax
movl %eax, %edx
callq 0x32c0
movzwl -0x1a(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movl $0x2, %esi
callq 0x3050
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: char2ke_pl
uint32_t char2ke_pl (uint8_t *buf, key_exchange_payload *pl)
{
    uint32_t offset = char2gen_pl_hdr (buf, &pl->header);   
    uint32_t length = pl->header.payload_length;
    CPY (buf, offset, pl->dh_group_num);
    CPY (buf, offset, pl->reserved);
    pl->key_exchange_data = calloc (length - offset, 1);
    MEMCHECK (pl->key_exchange_data);
    memcpy (pl->key_exchange_data, buf+offset, length - offset);
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3510
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
movl $0x2, %esi
callq 0x3050
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl -0x14(%rbp), %edx
movw (%rcx,%rdx), %cx
movw %cx, 0x4(%rax)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
movl $0x2, %esi
callq 0x3050
movl -0x14(%rbp), %eax
addq $0x2, %rax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
movl $0x2, %esi
callq 0x3050
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl -0x14(%rbp), %edx
movw (%rcx,%rdx), %cx
movw %cx, 0x6(%rax)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
movl $0x2, %esi
callq 0x3050
movl -0x14(%rbp), %eax
addq $0x2, %rax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x3250
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x47c8
movq 0xd852(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x88c8(%rip), %rsi      # 0xd078
leaq 0x88c5(%rip), %rdx      # 0xd07c
movb $0x0, %al
callq 0x3270
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x34c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %eax
addq %rax, %rsi
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x32c0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: nonce_pl2char
uint32_t nonce_pl2char (nonce_payload *pl, uint8_t *buf)
{
    uint32_t offset = gen_pl_hdr2char (&pl->header, buf);   
    uint32_t length = pl->header.payload_length;
    memcpy (buf+offset, pl->nonce_data, length - offset);
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x30a0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x4(%rax), %rsi
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x32c0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: char2nonce_pl
uint32_t char2nonce_pl (uint8_t *buf, nonce_payload *pl)
{
    uint32_t offset = char2gen_pl_hdr (buf, &pl->header);
    uint32_t length = pl->header.payload_length;
    pl->nonce_data = calloc (length - offset, 1);
    MEMCHECK (pl->nonce_data);
    memcpy (pl->nonce_data, buf+offset, length - offset);
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3510
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x3250
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x4(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x4(%rax)
jne 0x48de
movq 0xd73c(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x87b2(%rip), %rsi      # 0xd078
leaq 0x87af(%rip), %rdx      # 0xd07c
movb $0x0, %al
callq 0x3270
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x34c0
movq -0x10(%rbp), %rax
movq 0x4(%rax), %rdi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %eax
addq %rax, %rsi
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x32c0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: auth_pl2char
uint32_t auth_pl2char (authentication_payload *pl, uint8_t *buf)
{
    uint32_t offset = gen_pl_hdr2char (&pl->header, buf);
    uint32_t length = pl->header.payload_length;
    memcpy (buf+offset, &pl->auth_method, 4);
    offset += 4;
    memcpy (buf+offset, pl->authentication_data, length - offset);
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x30a0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rdx
movl 0x4(%rdx), %edx
movl %edx, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x32c0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: char2auth_pl
uint32_t char2auth_pl (uint8_t *buf, authentication_payload *pl)
{
    uint32_t offset = char2gen_pl_hdr (buf, &pl->header);
    uint32_t length = pl->header.payload_length;
    memcpy (&pl->auth_method, buf+offset, 4);
    offset += 4;
    pl->authentication_data = calloc (length - offset, 1);
    MEMCHECK (pl->authentication_data);
    memcpy (pl->authentication_data, buf+offset, length - offset);
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3510
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl -0x14(%rbp), %edx
movl (%rcx,%rdx), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x3250
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4a18
movq 0xd602(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x8678(%rip), %rsi      # 0xd078
leaq 0x8675(%rip), %rdx      # 0xd07c
movb $0x0, %al
callq 0x3270
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x34c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %eax
addq %rax, %rsi
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x32c0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: ts2char
uint32_t ts2char (traffic_selector *ts, uint8_t *buf)
{
    uint16_t length = ts->selector_length;
    uint32_t offset = 0;
    reverse ((uint8_t*)&ts->selector_length, sizeof (ts->selector_length));
    reverse ((uint8_t*)&ts->start_port, sizeof (ts->start_port));
    reverse ((uint8_t*)&ts->end_port, sizeof (ts->end_port));
    uint16_t tmp_l = sizeof (ts->TS_type) + sizeof (ts->IP_protocol_ID) +
        sizeof (ts->selector_length) + sizeof (ts->start_port) + sizeof (ts->end_port);
    memcpy (buf+offset, ts, tmp_l);
    offset += tmp_l;
    tmp_l = (length - tmp_l)/2;
    memcpy (buf+offset, ts->starting_address, tmp_l);
    offset += tmp_l;
    memcpy (buf+offset, ts->ending_address, tmp_l);
    reverse ((uint8_t*)&ts->selector_length, sizeof (ts->selector_length));
    reverse ((uint8_t*)&ts->start_port, sizeof (ts->start_port));
    reverse ((uint8_t*)&ts->end_port, sizeof (ts->end_port));
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movw 0x2(%rax), %ax
movw %ax, -0x12(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
movl $0x2, %esi
callq 0x3050
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movl $0x2, %esi
callq 0x3050
movq -0x8(%rbp), %rdi
addq $0x6, %rdi
movl $0x2, %esi
callq 0x3050
movw $0x8, -0x1a(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movzwl -0x1a(%rbp), %eax
movl %eax, %edx
callq 0x32c0
movzwl -0x1a(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movzwl -0x12(%rbp), %eax
movzwl -0x1a(%rbp), %ecx
subl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movw %ax, -0x1a(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movzwl -0x1a(%rbp), %eax
movl %eax, %edx
callq 0x32c0
movzwl -0x1a(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movzwl -0x1a(%rbp), %eax
movl %eax, %edx
callq 0x32c0
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
movl $0x2, %esi
callq 0x3050
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movl $0x2, %esi
callq 0x3050
movq -0x8(%rbp), %rdi
addq $0x6, %rdi
movl $0x2, %esi
callq 0x3050
movzwl -0x12(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: ts_pl2char
uint32_t ts_pl2char (traffic_selector_payload *pl, uint8_t *buf)
{
    uint32_t offset = gen_pl_hdr2char (&pl->header, buf);
    uint32_t length = pl->header.payload_length;
    memcpy (buf+offset, &pl->number_of_TSs, sizeof (pl->number_of_TSs) + 3);
    offset += sizeof (pl->number_of_TSs) + 3;
    for (uint32_t i = 0; i < pl->number_of_TSs; i++) 
        offset += ts2char (pl->traffic_selectors+i, buf+offset);
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x30a0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rdx
movl 0x4(%rdx), %edx
movl %edx, (%rax,%rcx)
movl -0x14(%rbp), %eax
addq $0x4, %rax
movl %eax, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jae 0x4f4e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x1c(%rbp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
addq %rax, %rsi
callq 0x3280
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4f0d
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: char2ts_pl
uint32_t char2ts_pl (uint8_t *buf, traffic_selector_payload *pl)
{
    uint32_t offset = char2gen_pl_hdr (buf, &pl->header);
    uint32_t length = pl->header.payload_length;
    memcpy (&pl->number_of_TSs, buf+offset, sizeof (pl->number_of_TSs) + 3);
    offset += sizeof (pl->number_of_TSs) + 3;
    pl->traffic_selectors = calloc (pl->number_of_TSs, sizeof (traffic_selector));
    for (uint32_t i = 0; i < pl->number_of_TSs; i++) 
        offset += char2ts (buf+offset, pl->traffic_selectors+i);
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3510
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl -0x14(%rbp), %edx
movl (%rcx,%rdx), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %eax
addq $0x4, %rax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
movl %eax, %edi
movl $0x18, %esi
callq 0x3250
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jae 0x500d
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x1c(%rbp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rsi
callq 0x34a0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4fcc
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: enc_pl2char
uint32_t enc_pl2char (encrypted_payload *pl, uint8_t *buf,
                 uint32_t iv_len,
                 uint32_t integ_key_len)
{
    uint32_t offset = gen_pl_hdr2char (&pl->header, buf);
    uint32_t length = pl->header.payload_length;
    memcpy (buf + offset, pl->iv, iv_len);
    offset += iv_len;
    memcpy (buf + offset, pl->enc_data, length - offset - integ_key_len);
    offset = length - integ_key_len;
    memcpy (buf + offset, pl->icv, integ_key_len);
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x30a0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x4(%rax), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x32c0
movl -0x14(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0xc(%rax), %rsi
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x32c0
movl -0x20(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x14(%rax), %rsi
movl -0x18(%rbp), %eax
movl %eax, %edx
callq 0x32c0
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./transforms.c
// Function: char2enc_pl
uint32_t char2enc_pl (uint8_t *buf, encrypted_payload *pl,
                 uint32_t iv_len,
                 uint32_t integ_key_len)
{
    uint32_t offset = char2gen_pl_hdr (buf, &pl->header);
    uint32_t length = pl->header.payload_length;
    pl->iv = calloc (1, iv_len);
    memcpy (pl->iv, buf + offset, iv_len);
    offset += iv_len;
    pl->enc_data = calloc (1, length - offset - integ_key_len);
    memcpy (pl->enc_data, buf + offset, length - offset - integ_key_len);
    offset = length - integ_key_len;
    pl->icv = calloc (1, integ_key_len);
    memcpy (pl->icv, buf + offset, integ_key_len);
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3510
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %esi
movl $0x1, %edi
callq 0x3250
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq 0x4(%rax), %rdi
movq -0x8(%rbp), %rsi
movl -0x1c(%rbp), %eax
addq %rax, %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x32c0
movl -0x14(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
movl $0x1, %edi
callq 0x3250
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xc(%rax)
movq -0x10(%rbp), %rax
movq 0xc(%rax), %rdi
movq -0x8(%rbp), %rsi
movl -0x1c(%rbp), %eax
addq %rax, %rsi
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x32c0
movl -0x20(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, %esi
movl $0x1, %edi
callq 0x3250
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x14(%rax)
movq -0x10(%rbp), %rax
movq 0x14(%rax), %rdi
movq -0x8(%rbp), %rsi
movl -0x1c(%rbp), %eax
addq %rax, %rsi
movl -0x18(%rbp), %eax
movl %eax, %edx
callq 0x32c0
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./dh_protocol.c
// Function: dh_nsize_random
mpz_srcptr dh_nsize_random (uint32_t size)
{
    mpz_t corr;
    mpz_init_set_ui (corr, 1);
    mpz_mul_2exp (corr, corr, (mp_bitcnt_t) size-1);
    mpz_urandomb (mpz_t_rez, state, (mp_bitcnt_t) size-1);
    mpz_add (mpz_t_rez, mpz_t_rez, corr);
    mpz_clear (corr);
    gmp_randseed (state, mpz_t_rez);
    return mpz_t_rez;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x33e0
leaq -0x20(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl -0x4(%rbp), %eax
movl %eax, %edx
subq $0x1, %rdx
callq 0x3230
movl -0x4(%rbp), %eax
movl %eax, %edx
subq $0x1, %rdx
leaq 0xd171(%rip), %rdi      # 0x12380
leaq 0xd17a(%rip), %rsi      # 0x12390
callq 0x35e0
leaq -0x20(%rbp), %rdx
leaq 0xd15a(%rip), %rsi      # 0x12380
movq %rsi, %rdi
callq 0x3460
leaq -0x20(%rbp), %rdi
callq 0x3300
leaq 0xd152(%rip), %rdi      # 0x12390
leaq 0xd13b(%rip), %rsi      # 0x12380
callq 0x3480
leaq 0xd12f(%rip), %rax      # 0x12380
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./dh_protocol.c
// Function: dh_initialize
void dh_initialize (void)
{
    mpz_init (mpz_t_rez);
    mpz_init (dh_a);
    mpz_init (dh_b);
    mpz_init (dh_g);
    mpz_init (dh_p);
    mpz_init (dh_A);
    mpz_init (dh_B);
    mpz_init (dh_K);

    gmp_randinit_mt (state);
    // gmp_randseed_ui (state, clock ());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xd115(%rip), %rdi      # 0x12380
callq 0x3520
leaq 0xd139(%rip), %rdi      # 0x123b0
callq 0x3520
leaq 0xd13d(%rip), %rdi      # 0x123c0
callq 0x3520
leaq 0xd141(%rip), %rdi      # 0x123d0
callq 0x3520
leaq 0xd145(%rip), %rdi      # 0x123e0
callq 0x3520
leaq 0xd149(%rip), %rdi      # 0x123f0
callq 0x3520
leaq 0xd14d(%rip), %rdi      # 0x12400
callq 0x3520
leaq 0xd151(%rip), %rdi      # 0x12410
callq 0x3520
leaq 0xd0c5(%rip), %rdi      # 0x12390
callq 0x32f0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./dh_protocol.c
// Function: dh_clear
void dh_clear (void)
{
    mpz_clear (mpz_t_rez);
    mpz_clear (dh_a);
    mpz_clear (dh_b);
    mpz_clear (dh_g);
    mpz_clear (dh_p);
    mpz_clear (dh_A);
    mpz_clear (dh_B);
    mpz_clear (dh_K);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xd095(%rip), %rdi      # 0x12380
callq 0x3300
leaq 0xd0b9(%rip), %rdi      # 0x123b0
callq 0x3300
leaq 0xd0bd(%rip), %rdi      # 0x123c0
callq 0x3300
leaq 0xd0c1(%rip), %rdi      # 0x123d0
callq 0x3300
leaq 0xd0c5(%rip), %rdi      # 0x123e0
callq 0x3300
leaq 0xd0c9(%rip), %rdi      # 0x123f0
callq 0x3300
leaq 0xd0cd(%rip), %rdi      # 0x12400
callq 0x3300
leaq 0xd0d1(%rip), %rdi      # 0x12410
callq 0x3300
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/./dh_protocol.c
// Function: get_modp
uint32_t get_modp (uint32_t dh_group)
{
    switch (dh_group)
    {
        case MODP_768:   return 768;
        case MODP_1024:  return 1024;
        case MODP_1536:  return 1536;
        case MODP_2048:  return 2048;
        case MODP_3072:  return 3072;
        case MODP_4096:  return 4096;
        case MODP_6144:  return 6144;
        case MODP_8192:  return 8192;
        case DH_GR_NONE: return 0;
        default:         return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x12, %rax
ja 0x5599
movq -0x10(%rbp), %rax
leaq 0x7ac1(%rip), %rcx      # 0xd000
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x300, -0x4(%rbp)      # imm = 0x300
jmp 0x55a0
movl $0x400, -0x4(%rbp)      # imm = 0x400
jmp 0x55a0
movl $0x600, -0x4(%rbp)      # imm = 0x600
jmp 0x55a0
movl $0x800, -0x4(%rbp)      # imm = 0x800
jmp 0x55a0
movl $0xc00, -0x4(%rbp)      # imm = 0xC00
jmp 0x55a0
movl $0x1000, -0x4(%rbp)     # imm = 0x1000
jmp 0x55a0
movl $0x1800, -0x4(%rbp)     # imm = 0x1800
jmp 0x55a0
movl $0x2000, -0x4(%rbp)     # imm = 0x2000
jmp 0x55a0
movl $0x0, -0x4(%rbp)
jmp 0x55a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/ike.c
// Function: init
void init (void)
{
    dh_initialize ();
    // srand (time (NULL));
    SPIi = calloc (1, sizeof (uint64_t));
    SPIr = calloc (1, sizeof (uint64_t));

    MID = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x31a0
movl $0x1, %edi
movl $0x8, %esi
callq 0x3250
movq %rax, 0xcb91(%rip)      # 0x12420
movl $0x1, %edi
movl $0x8, %esi
callq 0x3250
movq %rax, 0xcb83(%rip)      # 0x12428
movl $0x0, 0xcb81(%rip)      # 0x12430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/ike.c
// Function: mem_clr
void mem_clr (void)
{
    sa_pl_clr (&SAi1);
    sa_pl_clr (&SAi2);
    sa_pl_clr (&SAr1);
    sa_pl_clr (&SAr2);
    ke_pl_clr (&KEi);
    ke_pl_clr (&KEr);
    id_pl_clr (&IDi);
    id_pl_clr (&IDr);
    // cert_pl_clr (&CERT);
    // cert_req_pl_clr (&CERTREQ);
    auth_pl_clr (&AUTH);
    nonce_pl_clr (&Ni);
    nonce_pl_clr (&Nr);
    ts_pl_clr (&TSi);
    ts_pl_clr (&TSr);

    enc_pl_clr (&SK);

    sa_pl_clr (&SA_recv);
    // ke_pl_clr (&KE_recv);
    id_pl_clr (&IDi_recv);
    id_pl_clr (&IDr_recv);

    auth_pl_clr(&AUTH_recv);
    // nonce_pl_clr (&NONCE_recv);
    // puts ("14");

    ts_pl_clr (&TSi_recv);
    ts_pl_clr (&TSr_recv);

    enc_pl_clr (&SK_recv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xcb69(%rip), %rdi      # 0x12434
callq 0x3030
leaq 0xcb69(%rip), %rdi      # 0x12440
callq 0x3030
leaq 0xcb69(%rip), %rdi      # 0x1244c
callq 0x3030
leaq 0xcb69(%rip), %rdi      # 0x12458
callq 0x3030
leaq 0xcb6d(%rip), %rdi      # 0x12468
callq 0x35b0
leaq 0xcb71(%rip), %rdi      # 0x12478
callq 0x35b0
leaq 0xcb75(%rip), %rdi      # 0x12488
callq 0x3560
leaq 0xcb79(%rip), %rdi      # 0x12498
callq 0x3560
leaq 0xcb7d(%rip), %rdi      # 0x124a8
callq 0x3100
leaq 0xcb81(%rip), %rdi      # 0x124b8
callq 0x3330
leaq 0xcb81(%rip), %rdi      # 0x124c4
callq 0x3330
leaq 0xcb81(%rip), %rdi      # 0x124d0
callq 0x3320
leaq 0xcb85(%rip), %rdi      # 0x124e0
callq 0x3320
leaq 0xcb89(%rip), %rdi      # 0x124f0
callq 0x3590
leaq 0xcb99(%rip), %rdi      # 0x1250c
callq 0x3030
leaq 0xcb99(%rip), %rdi      # 0x12518
callq 0x3560
leaq 0xcb9d(%rip), %rdi      # 0x12528
callq 0x3560
leaq 0xcba1(%rip), %rdi      # 0x12538
callq 0x3100
leaq 0xcba5(%rip), %rdi      # 0x12548
callq 0x3320
leaq 0xcba9(%rip), %rdi      # 0x12558
callq 0x3320
leaq 0xcbad(%rip), %rdi      # 0x12568
callq 0x3590
popq %rbp
retq
nopw %cs:(%rax,%rax)