LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/ike.c
// Function: get_id_len
int get_id_len (uint32_t id_type)
{
    switch (id_type)
    {
        case ID_IPV4_ADDR:   return 4;
        case ID_FQDN:        return 0;
        case ID_RFC822_ADDR: return 0;
        case ID_IPV6_ADDR:   return 16;
        case ID_DER_ASN1_DN: return 0;
        case ID_DER_ASN1_GN: return 0;
        case ID_KEY_ID:      return 0;
        default:             return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0xa, %eax
ja 0x6dca
movq -0x10(%rbp), %rax
leaq 0x62ca(%rip), %rcx      # 0xd04c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4, -0x4(%rbp)
jmp 0x6dd1
movl $0x0, -0x4(%rbp)
jmp 0x6dd1
movl $0x0, -0x4(%rbp)
jmp 0x6dd1
movl $0x10, -0x4(%rbp)
jmp 0x6dd1
movl $0x0, -0x4(%rbp)
jmp 0x6dd1
movl $0x0, -0x4(%rbp)
jmp 0x6dd1
movl $0x0, -0x4(%rbp)
jmp 0x6dd1
movl $0x0, -0x4(%rbp)
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: integ_func
void integ_func (uint8_t *key, uint32_t keylen,
                 uint8_t *data, uint32_t datalen,
                 uint8_t *output)
{
    if (acc_prf == AUTH_HMAC_SHA1_96)
        hmac_sha1 (key, keylen,
                   data, datalen,
                   output);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movzwl 0xb84b(%rip), %eax      # 0x1264c
cmpl $0x2, %eax
jne 0x6e21
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %eax
movl %eax, %ecx
movq -0x28(%rbp), %r8
callq 0x33c0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/ike.c
// Function: check_icv
int check_icv (void)
{
    uint8_t *icv = calloc (1, integ_key_len);
    uint8_t *key = (HDR_recv.flags == XXI)?SK_ai:SK_ar;
    integ_func (key, integ_key_len,
                buff, HDR_recv.length - integ_key_len,
                icv);
    for (int i = 0; i < integ_key_len; i++)
        if (icv[i] != SK_recv.icv[i])
            return INVALID;
    return VALID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movzwl 0xa9f1(%rip), %eax      # 0x12600
movl %eax, %esi
movl $0x1, %edi
callq 0x3250
movq %rax, -0x10(%rbp)
movzbl 0xa9bd(%rip), %eax      # 0x125e3
cmpl $0x8, %eax
jne 0x7c38
movq 0xa9ee(%rip), %rax      # 0x12620
movq %rax, -0x28(%rbp)
jmp 0x7c43
movq 0xaa01(%rip), %rax      # 0x12640
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movzwl 0xa9aa(%rip), %esi      # 0x12600
movq 0xa943(%rip), %rdx      # 0x125a0
movl 0xa985(%rip), %ecx      # 0x125e8
movzwl 0xa996(%rip), %eax      # 0x12600
subl %eax, %ecx
movq -0x10(%rbp), %r8
callq 0x3040
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movzwl 0xa97a(%rip), %ecx      # 0x12600
cmpl %ecx, %eax
jge 0x7cbf
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq 0xa8df(%rip), %rcx      # 0x1257c
movslq -0x1c(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x7cb2
movl $0x0, -0x4(%rbp)
jmp 0x7cc6
jmp 0x7cb4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7c7c
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/ike.c
// Function: parse_SK
int parse_SK (void)
{
    free (buff);
    buff = calloc (1, sizeof (ike_header) + SK_recv.header.payload_length);
    ike_header HDR = HDR_recv;
    HDR.next_payload = SK_recv.header.next_payload;
    HDR.length = sizeof (ike_header) + SK_recv.header.payload_length;
    uint32_t offset = ike_hdr2char (&HDR, buff);
    uint8_t *key_e = (HDR_recv.flags == XXI)?SK_ei:SK_er;
    decr_func (buff + offset,
               SK_recv.enc_data,
               SK_recv.header.payload_length - integ_key_len,
               key_e,
               SK_recv.iv);
    parse_buff ();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0xa8c1(%rip), %rdi      # 0x125a0
callq 0x3060
movzwl 0xa87f(%rip), %eax      # 0x1256a
movl %eax, %esi
addq $0x1c, %rsi
movl $0x1, %edi
callq 0x3250
movq %rax, 0xa89e(%rip)      # 0x125a0
movq 0xa8c7(%rip), %rax      # 0x125d0
movq %rax, -0x1c(%rbp)
movq 0xa8c4(%rip), %rax      # 0x125d8
movq %rax, -0x14(%rbp)
movq 0xa8c1(%rip), %rax      # 0x125e0
movq %rax, -0xc(%rbp)
movl 0xa8bf(%rip), %eax      # 0x125e8
movl %eax, -0x4(%rbp)
movb 0xa836(%rip), %al       # 0x12568
movb %al, -0xc(%rbp)
movzwl 0xa82e(%rip), %eax      # 0x1256a
addq $0x1c, %rax
movl %eax, -0x4(%rbp)
movq 0xa856(%rip), %rsi      # 0x125a0
leaq -0x1c(%rbp), %rdi
callq 0x3490
movl %eax, -0x20(%rbp)
movzbl 0xa886(%rip), %eax      # 0x125e3
cmpl $0x8, %eax
jne 0x7d6f
movq 0xa8af(%rip), %rax      # 0x12618
movq %rax, -0x30(%rbp)
jmp 0x7d7a
movq 0xa8ba(%rip), %rax      # 0x12630
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0xa817(%rip), %rdi      # 0x125a0
movl -0x20(%rbp), %eax
addq %rax, %rdi
movq 0xa7de(%rip), %rsi      # 0x12574
movzwl 0xa7cd(%rip), %edx      # 0x1256a
movzwl 0xa85c(%rip), %eax      # 0x12600
subl %eax, %edx
movq -0x28(%rbp), %rcx
movq 0xa7bb(%rip), %r8       # 0x1256c
callq 0x3090
callq 0x3390
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/ike.c
// Function: get_key_len
int get_key_len (transform *trans)
{
    if (trans->transform_length > 8 &&
        trans->attribute_type == AT_KEY_LEN)
        return (trans->attribute_value[0] << 8) + trans->attribute_value[1];
    else if (trans->transform_type == ENCR)
        if (trans->transform_ID == ENCR_DES_IV64 ||
            trans->transform_ID == ENCR_DES_IV32 ||
            trans->transform_ID == ENCR_DES)
            return 64;
        else if (trans->transform_ID == ENCR_3DES)
            return 168;
        else if (trans->transform_ID == ENCR_RC5 ||
                 trans->transform_ID == ENCR_IDEA)
            return 128;
        else if (trans->transform_ID == ENCR_NULL)
            return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %eax
cmpl $0x8, %eax
jle 0x7e76
movq -0x10(%rbp), %rax
movzbl 0x9(%rax), %eax
cmpl $0xe, %eax
jne 0x7e76
movq -0x10(%rbp), %rax
movq 0xa(%rax), %rax
movzbl (%rax), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movq 0xa(%rcx), %rcx
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x7f10
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x1, %eax
jne 0x7f0e
movq -0x10(%rbp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x1, %eax
je 0x7eae
movq -0x10(%rbp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x9, %eax
je 0x7eae
movq -0x10(%rbp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x2, %eax
jne 0x7eb7
movl $0x40, -0x4(%rbp)
jmp 0x7f10
movq -0x10(%rbp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x3, %eax
jne 0x7ecd
movl $0xa8, -0x4(%rbp)
jmp 0x7f10
movq -0x10(%rbp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x4, %eax
je 0x7ee7
movq -0x10(%rbp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x5, %eax
jne 0x7ef0
movl $0x80, -0x4(%rbp)
jmp 0x7f10
movq -0x10(%rbp), %rax
movzwl 0x6(%rax), %eax
cmpl $0xb, %eax
jne 0x7f06
movl $0x0, -0x4(%rbp)
jmp 0x7f10
jmp 0x7f08
jmp 0x7f0a
jmp 0x7f0c
jmp 0x7f0e
jmp 0x7f10
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: get_block_len
int get_block_len (uint16_t encr, uint16_t encr_key_len)
{
    if (encr == ENCR_AES_CBC ||
        encr == ENCR_AES_CTR)
        return 128;
    else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movw %di, %cx
movw %cx, -0x6(%rbp)
movw %ax, -0x8(%rbp)
movzwl -0x6(%rbp), %eax
cmpl $0xc, %eax
je 0x7f44
movzwl -0x6(%rbp), %eax
cmpl $0xd, %eax
jne 0x7f4d
movl $0x80, -0x4(%rbp)
jmp 0x7f54
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/ike.c
// Function: get_iv_len
int get_iv_len (uint16_t encr, uint16_t encr_key_len)
{
    if (encr == ENCR_AES_CBC ||
        encr == ENCR_AES_CTR)
        return 128;
    else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movw %di, %cx
movw %cx, -0x6(%rbp)
movw %ax, -0x8(%rbp)
movzwl -0x6(%rbp), %eax
cmpl $0xc, %eax
je 0x7f84
movzwl -0x6(%rbp), %eax
cmpl $0xd, %eax
jne 0x7f8d
movl $0x80, -0x4(%rbp)
jmp 0x7f94
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/ike.c
// Function: print_packet
void print_packet (void)
{
    const char size = 16;
    ike_header hdr;
    char2ike_hdr (buff, &hdr);

    for (int i = 0; i < hdr.length; i++)
    {
        if (i % size == 0) printf ("%03x-%03x  ", i, i+size-1);
        printf ("%02x:", buff[i]);
        if (i % size == size-1 && i != hdr.length-1) puts ("");
    }
    puts ("");

    // printf ("b'");
    // for (int i = 0; i < hdr.length; i++)
    // {
    //     printf ("\\x%02x", buff[i]);
    // }
    // puts ("'");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb $0x10, -0x1(%rbp)
movq 0x9e7d(%rip), %rdi      # 0x125a0
leaq -0x1d(%rbp), %rsi
callq 0x3240
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x5(%rbp), %eax
jae 0x87bf
movl -0x24(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x8769
movl -0x24(%rbp), %esi
movl -0x24(%rbp), %edx
addl $0x10, %edx
subl $0x1, %edx
leaq 0x6996(%rip), %rdi      # 0xf0f8
movb $0x0, %al
callq 0x3180
movq 0x9e30(%rip), %rax      # 0x125a0
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x6985(%rip), %rdi      # 0xf104
movb $0x0, %al
callq 0x3180
movl -0x24(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
cmpl $0xf, %edx
jne 0x87af
movl -0x24(%rbp), %eax
movl -0x5(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x87af
leaq 0x69a3(%rip), %rdi      # 0xf14d
callq 0x30b0
jmp 0x87b1
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8733
leaq 0x6987(%rip), %rdi      # 0xf14d
callq 0x30b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/ike.c
// Function: dbg_print
void dbg_print (void)
{
    // printf ("SPIi:\n");
    // dbg_print_buf (SPIi, sizeof (long long));

    // printf ("SPIr:\n");
    // dbg_print_buf (SPIr, sizeof (long long));

    // printf ("Ni:\n");
    // dbg_print_buf (Ni.nonce_data, Ni_len);

    // printf ("Nr:\n");
    // dbg_print_buf (Nr.nonce_data, Nr_len);

    // printf ("K:\n");
    // dbg_print_buf (K, modp/8);

    printf ("SK_d:\n");
    dbg_print_buf (SK_d, prf_key_len);

    printf ("SK_ai:\n");
    dbg_print_buf (SK_ai, integ_key_len);

    printf ("SK_ar:\n");
    dbg_print_buf (SK_ar, integ_key_len);

    printf ("SK_ei:\n");
    dbg_print_buf (SK_ei, encr_key_len);

    printf ("SK_er:\n");
    dbg_print_buf (SK_er, encr_key_len);

    printf ("SK_pi:\n");
    dbg_print_buf (SK_pi, prf_key_len);

    printf ("SK_pr:\n");
    dbg_print_buf (SK_pr, prf_key_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x691f(%rip), %rdi      # 0xf10a
movb $0x0, %al
callq 0x3180
movq 0x9e5f(%rip), %rdi      # 0x12658
movzwl 0x9e4a(%rip), %esi      # 0x1264a
callq 0x3160
leaq 0x6905(%rip), %rdi      # 0xf111
movb $0x0, %al
callq 0x3180
movq 0x9e06(%rip), %rdi      # 0x12620
movzwl 0x9ddf(%rip), %esi      # 0x12600
callq 0x3160
leaq 0x68ec(%rip), %rdi      # 0xf119
movb $0x0, %al
callq 0x3180
movq 0x9e05(%rip), %rdi      # 0x12640
movzwl 0x9dbe(%rip), %esi      # 0x12600
callq 0x3160
leaq 0x68d3(%rip), %rdi      # 0xf121
movb $0x0, %al
callq 0x3180
movq 0x9dbc(%rip), %rdi      # 0x12618
movzwl 0x9de5(%rip), %esi      # 0x12648
callq 0x3160
leaq 0x68ba(%rip), %rdi      # 0xf129
movb $0x0, %al
callq 0x3180
movq 0x9db3(%rip), %rdi      # 0x12630
movzwl 0x9dc4(%rip), %esi      # 0x12648
callq 0x3160
leaq 0x68a1(%rip), %rdi      # 0xf131
movb $0x0, %al
callq 0x3180
movq 0x9d6a(%rip), %rdi      # 0x12608
movzwl 0x9da5(%rip), %esi      # 0x1264a
callq 0x3160
leaq 0x6888(%rip), %rdi      # 0xf139
movb $0x0, %al
callq 0x3180
movq 0x9d69(%rip), %rdi      # 0x12628
movzwl 0x9d84(%rip), %esi      # 0x1264a
callq 0x3160
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/ike.c
// Function: dbg_print_buf
void dbg_print_buf (uint8_t *buf, uint32_t len)
{
     printf ("b'");
     for (int i = 0; i < len; i++)
         printf ("\\x%02x", buf[i]);
     puts ("'\n");

    // for (int i = 0; i < len; i++)
    //     printf ("%02x:", buf[i]);
    // puts ("");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x685b(%rip), %rdi      # 0xf141
movb $0x0, %al
callq 0x3180
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x8921
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x6835(%rip), %rdi      # 0xf144
movb $0x0, %al
callq 0x3180
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x88f4
leaq 0x6823(%rip), %rdi      # 0xf14b
callq 0x30b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/hmac/hmac-sha1.c
// Function: hmac_sha1
int
hmac_sha1 (const void *key, size_t keylen,
	   const void *in, size_t inlen, void *resbuf)
{
  struct sha1_ctx inner;
  struct sha1_ctx outer;
  char optkeybuf[20];
  char block[64];
  char innerhash[20];

  /* Reduce the key's size, so that it becomes <= 64 bytes large.  */

  if (keylen > 64)
    {
      struct sha1_ctx keyhash;

      sha1_init_ctx (&keyhash);
      sha1_process_bytes (key, keylen, &keyhash);
      sha1_finish_ctx (&keyhash, optkeybuf);

      key = optkeybuf;
      keylen = 20;
    }

  /* Compute INNERHASH from KEY and IN.  */

  sha1_init_ctx (&inner);

  memset (block, IPAD, sizeof (block));
  memxor (block, key, keylen);

  sha1_process_block (block, 64, &inner);
  sha1_process_bytes (in, inlen, &inner);

  sha1_finish_ctx (&inner, innerhash);

  /* Compute result from KEY and INNERHASH.  */

  sha1_init_ctx (&outer);

  memset (block, OPAD, sizeof (block));
  memxor (block, key, keylen);

  sha1_process_block (block, 64, &outer);
  sha1_process_bytes (innerhash, 20, &outer);

  sha1_finish_ctx (&outer, resbuf);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x40, -0x10(%rbp)
jbe 0x89ac
leaq -0x280(%rbp), %rdi
callq 0x3570
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x280(%rbp), %rdx
callq 0x35d0
leaq -0x180(%rbp), %rsi
leaq -0x280(%rbp), %rdi
callq 0x31d0
leaq -0x180(%rbp), %rax
movq %rax, -0x8(%rbp)
movq $0x14, -0x10(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x3570
leaq -0x1c0(%rbp), %rdi
movl $0x36, %esi
movl $0x40, %edx
callq 0x31c0
leaq -0x1c0(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x30c0
leaq -0x1c0(%rbp), %rdi
movl $0x40, %esi
leaq -0xc8(%rbp), %rdx
callq 0x35a0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq 0x35d0
leaq -0x1e0(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x31d0
leaq -0x168(%rbp), %rdi
callq 0x3570
leaq -0x1c0(%rbp), %rdi
movl $0x5c, %esi
movl $0x40, %edx
callq 0x31c0
leaq -0x1c0(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x30c0
leaq -0x1c0(%rbp), %rdi
movl $0x40, %esi
leaq -0x168(%rbp), %rdx
callq 0x35a0
leaq -0x1e0(%rbp), %rdi
movl $0x14, %esi
leaq -0x168(%rbp), %rdx
callq 0x35d0
movq -0x28(%rbp), %rsi
leaq -0x168(%rbp), %rdi
callq 0x31d0
xorl %eax, %eax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/hmac/base64.c
// Function: decodeblock
void decodeblock(unsigned char in[], char *clrstr) {
	unsigned char out[4];
	out[0] = in[0] << 2 | in[1] >> 4;
	out[1] = in[1] << 4 | in[2] >> 2;
	out[2] = in[2] << 6 | in[3] >> 0;
	out[3] = '\0';
	strncat(clrstr, out, sizeof(out));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
shll $0x2, %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
sarl $0x4, %ecx
orl %ecx, %eax
movb %al, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
shll $0x4, %eax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
sarl $0x2, %ecx
orl %ecx, %eax
movb %al, -0x13(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x2(%rax), %eax
shll $0x6, %eax
movq -0x8(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
sarl $0x0, %ecx
orl %ecx, %eax
movb %al, -0x12(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
movl $0x4, %edx
callq 0x3200
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/hmac/base64.c
// Function: b64_decode
void b64_decode(char *b64src, char *clrdst) {
	int c, phase, i;
	unsigned char in[4];
	char *p;

	clrdst[0] = '\0';
	phase = 0; i=0;
	while(b64src[i]) {
		c = (int) b64src[i];
		if(c == '=') {
			decodeblock(in, clrdst); 
			break;
		}
		p = strchr(b64, c);
		if(p) {
			in[phase] = p - b64;
			phase = (phase + 1) % 4;
			if(phase == 0) {
				decodeblock(in, clrdst);
				in[0]=in[1]=in[2]=in[3]=0;
			}
		}
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x8c01
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x3d, -0x14(%rbp)
jne 0x8b8b
leaq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3340
jmp 0x8c01
movl -0x14(%rbp), %esi
movq 0x944b(%rip), %rdi      # 0x11fe0
callq 0x3170
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8bf3
movq -0x28(%rbp), %rax
movq 0x9430(%rip), %rcx      # 0x11fe0
subq %rcx, %rax
movb %al, %cl
movslq -0x18(%rbp), %rax
movb %cl, -0x20(%rbp,%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x8bf1
leaq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3340
movb $0x0, -0x1d(%rbp)
movb $0x0, -0x1e(%rbp)
movb $0x0, -0x1f(%rbp)
movb $0x0, -0x20(%rbp)
jmp 0x8bf3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8b55
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/hmac/base64.c
// Function: encodeblock
void encodeblock( unsigned char in[], char b64str[], int len ) {
	unsigned char out[5];
	out[0] = b64[ in[0] >> 2 ];
	out[1] = b64[ ((in[0] & 0x03) << 4) | ((in[1] & 0xf0) >> 4) ];
	out[2] = (unsigned char) (len > 1 ? b64[ ((in[1] & 0x0f) << 2) |
		((in[2] & 0xc0) >> 6) ] : '=');
	out[3] = (unsigned char) (len > 2 ? b64[ in[2] & 0x3f ] : '=');
	out[4] = '\0';
	strncat(b64str, out, sizeof(out));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
sarl $0x2, %eax
movslq %eax, %rcx
movq 0x93a9(%rip), %rax      # 0x11fe0
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x3, %eax
shll $0x4, %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
andl $0xf0, %ecx
sarl $0x4, %ecx
orl %ecx, %eax
movslq %eax, %rcx
movq 0x9379(%rip), %rax      # 0x11fe0
movb (%rax,%rcx), %al
movb %al, -0x18(%rbp)
cmpl $0x1, -0x14(%rbp)
jle 0x8ca7
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
andl $0xf, %eax
shll $0x2, %eax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
andl $0xc0, %ecx
sarl $0x6, %ecx
orl %ecx, %eax
movslq %eax, %rcx
movq 0x9342(%rip), %rax      # 0x11fe0
movsbl (%rax,%rcx), %eax
movl %eax, -0x20(%rbp)
jmp 0x8cb1
movl $0x3d, %eax
movl %eax, -0x20(%rbp)
jmp 0x8cb1
movl -0x20(%rbp), %eax
movb %al, -0x17(%rbp)
cmpl $0x2, -0x14(%rbp)
jle 0x8cdb
movq -0x8(%rbp), %rax
movzbl 0x2(%rax), %eax
andl $0x3f, %eax
movslq %eax, %rcx
movq 0x930e(%rip), %rax      # 0x11fe0
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
jmp 0x8ce5
movl $0x3d, %eax
movl %eax, -0x24(%rbp)
jmp 0x8ce5
movl -0x24(%rbp), %eax
movb %al, -0x16(%rbp)
movb $0x0, -0x15(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x19(%rbp), %rsi
movl $0x5, %edx
callq 0x3200
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/hmac/base64.c
// Function: b64_encode
void b64_encode(char *clrstr, char *b64dst) {
	unsigned char in[3];
	int i, len = 0;
	int j = 0;

	b64dst[0] = '\0';
	while(clrstr[j]) {
		len = 0;
		for(i=0; i<3; i++) {
			in[i] = (unsigned char) clrstr[j];
			if(clrstr[j]) {
				len++; j++;
			}
			else in[i] = 0;
		}
		if( len ) {
			encodeblock( in, b64dst, len );
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x8dbd
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x3, -0x18(%rbp)
jge 0x8da2
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %cl
movslq -0x18(%rbp), %rax
movb %cl, -0x13(%rbp,%rax)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x8d8c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8d95
movslq -0x18(%rbp), %rax
movb $0x0, -0x13(%rbp,%rax)
jmp 0x8d97
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8d51
cmpl $0x0, -0x1c(%rbp)
je 0x8db8
leaq -0x13(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x3540
jmp 0x8d35
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/hmac/memxor.c
// Function: memxor
void *
memxor (void */*restrict*/ dest, const void */*restrict*/ src, size_t n)
{
  char const *s = (char const*)src;
  char *d = (char*)dest;

  for (; n > 0; n--)
    *d++ ^= *s++;

  return dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x8e2d
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movsbl (%rax), %edx
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movsbl (%rax), %ecx
xorl %edx, %ecx
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x8df0
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/hmac/sha1.c
// Function: sha1_read_ctx
void *
sha1_read_ctx (const struct sha1_ctx *ctx, void *resbuf)
{
  char *r = (char*)resbuf;
  set_uint32 (r + 0 * sizeof ctx->A, SWAP (ctx->A));
  set_uint32 (r + 1 * sizeof ctx->B, SWAP (ctx->B));
  set_uint32 (r + 2 * sizeof ctx->C, SWAP (ctx->C));
  set_uint32 (r + 3 * sizeof ctx->D, SWAP (ctx->D));
  set_uint32 (r + 4 * sizeof ctx->E, SWAP (ctx->E));

  return resbuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
shll $0x18, %esi
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
shll $0x8, %eax
orl %eax, %esi
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
orl %eax, %esi
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x18, %eax
orl %eax, %esi
callq 0x9030
movq -0x18(%rbp), %rdi
addq $0x4, %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
shll $0x18, %esi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
shll $0x8, %eax
orl %eax, %esi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
shrl $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
orl %eax, %esi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
shrl $0x18, %eax
orl %eax, %esi
callq 0x9030
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
shll $0x18, %esi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
shll $0x8, %eax
orl %eax, %esi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
orl %eax, %esi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0x18, %eax
orl %eax, %esi
callq 0x9030
movq -0x18(%rbp), %rdi
addq $0xc, %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
shll $0x18, %esi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
shll $0x8, %eax
orl %eax, %esi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
shrl $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
orl %eax, %esi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
shrl $0x18, %eax
orl %eax, %esi
callq 0x9030
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
shll $0x18, %esi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
shll $0x8, %eax
orl %eax, %esi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
orl %eax, %esi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x18, %eax
orl %eax, %esi
callq 0x9030
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/hmac/sha1.c
// Function: sha1_finish_ctx
void *
sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf)
{
  /* Take yet unprocessed bytes into account.  */
  uint32_t bytes = ctx->buflen;
  size_t size = (bytes < 56) ? 64 / 4 : 64 * 2 / 4;

  /* Now count remaining bytes.  */
  ctx->total[0] += bytes;
  if (ctx->total[0] < bytes)
    ++ctx->total[1];

  /* Put the 64-bit file length in *bits* at the end of the buffer.  */
  ctx->buffer[size - 2] = SWAP ((ctx->total[1] << 3) | (ctx->total[0] >> 29));
  ctx->buffer[size - 1] = SWAP (ctx->total[0] << 3);

  memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes);

  /* Process last bytes.  */
  sha1_process_block (ctx->buffer, size * 4, ctx);

  return sha1_read_ctx (ctx, resbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edx
movl $0x20, %eax
movl $0x10, %ecx
cmpl $0x38, %edx
cmovbl %ecx, %eax
cltq
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0x14(%rbp), %eax
jae 0x90a9
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edx
shll $0x3, %edx
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shrl $0x1d, %eax
orl %eax, %edx
shll $0x18, %edx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
shll $0x3, %eax
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %ecx
shrl $0x1d, %ecx
orl %ecx, %eax
andl $0xff00, %eax           # imm = 0xFF00
shll $0x8, %eax
orl %eax, %edx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
shll $0x3, %eax
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %ecx
shrl $0x1d, %ecx
orl %ecx, %eax
shrl $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
orl %eax, %edx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
shll $0x3, %eax
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %ecx
shrl $0x1d, %ecx
orl %ecx, %eax
shrl $0x18, %eax
orl %eax, %edx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x2, %rcx
movl %edx, 0x20(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %edx
shll $0x3, %edx
shll $0x18, %edx
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shll $0x3, %eax
andl $0xff00, %eax           # imm = 0xFF00
shll $0x8, %eax
orl %eax, %edx
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shll $0x3, %eax
shrl $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
orl %eax, %edx
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shll $0x3, %eax
shrl $0x18, %eax
orl %eax, %edx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movl %edx, 0x20(%rax,%rcx,4)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
movq -0x20(%rbp), %rdx
subq $0x2, %rdx
shlq $0x2, %rdx
movl -0x14(%rbp), %eax
subq %rax, %rdx
leaq 0x5fa8(%rip), %rsi      # 0xf150
callq 0x32c0
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rsi
shlq $0x2, %rsi
movq -0x8(%rbp), %rdx
callq 0x35a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x35c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/crypt/aes128.c
// Function: AES128_ECB_encrypt
void AES128_ECB_encrypt(const uint8_t* input, const uint8_t* key, uint8_t* output)
{
  // Copy input to output, and work in-memory on output
  BlockCopy(output, input);
  state = (state_t*)output;

  Key = key;
  KeyExpansion();

  // The next function call encrypts the PlainText with the Key using AES algorithm.
  Cipher();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xb570
movq -0x18(%rbp), %rax
movq %rax, 0x7114(%rip)      # 0x12660
movq -0x10(%rbp), %rax
movq %rax, 0x7111(%rip)      # 0x12668
callq 0xb5b0
callq 0xb850
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/crypt/aes128.c
// Function: Cipher
static void Cipher(void)
{
  uint8_t round = 0;

  // Add the First round key to the state before starting the rounds.
  AddRoundKey(0); 
  
  // There will be Nr rounds.
  // The first Nr-1 rounds are identical.
  // These Nr-1 rounds are executed in the loop below.
  for(round = 1; round < Nr; ++round)
  {
    SubBytes();
    ShiftRows();
    MixColumns();
    AddRoundKey(round);
  }
  
  // The last round is given below.
  // The MixColumns function is not here in the last round.
  SubBytes();
  ShiftRows();
  AddRoundKey(Nr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, -0x1(%rbp)
xorl %edi, %edi
callq 0xbc10
movb $0x1, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
cmpl $0xa, %eax
jge 0xb892
callq 0xbca0
callq 0xbd20
callq 0xbe30
movzbl -0x1(%rbp), %edi
callq 0xbc10
movb -0x1(%rbp), %al
addb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xb867
callq 0xbca0
callq 0xbd20
movl $0xa, %edi
callq 0xbc10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/crypt/aes128.c
// Function: AES128_ECB_decrypt
void AES128_ECB_decrypt(const uint8_t* input, const uint8_t* key, uint8_t *output)
{
  // Copy input to output, and work in-memory on output
  BlockCopy(output, input);
  state = (state_t*)output;

  // The KeyExpansion routine must be called before encryption.
  Key = key;
  KeyExpansion();

  InvCipher();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xb570
movq -0x18(%rbp), %rax
movq %rax, 0x6d84(%rip)      # 0x12660
movq -0x10(%rbp), %rax
movq %rax, 0x6d81(%rip)      # 0x12668
callq 0xb5b0
callq 0xb900
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/crypt/aes128.c
// Function: InvCipher
static void InvCipher(void)
{
  uint8_t round=0;

  // Add the First round key to the state before starting the rounds.
  AddRoundKey(Nr); 

  // There will be Nr rounds.
  // The first Nr-1 rounds are identical.
  // These Nr-1 rounds are executed in the loop below.
  for(round=Nr-1;round>0;round--)
  {
    InvShiftRows();
    InvSubBytes();
    AddRoundKey(round);
    InvMixColumns();
  }
  
  // The last round is given below.
  // The MixColumns function is not here in the last round.
  InvShiftRows();
  InvSubBytes();
  AddRoundKey(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, -0x1(%rbp)
movl $0xa, %edi
callq 0xbc10
movb $0x9, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
cmpl $0x0, %eax
jle 0xb945
callq 0xc020
callq 0xc130
movzbl -0x1(%rbp), %edi
callq 0xbc10
callq 0xc1b0
movb -0x1(%rbp), %al
addb $-0x1, %al
movb %al, -0x1(%rbp)
jmp 0xb91a
callq 0xc020
callq 0xc130
xorl %edi, %edi
callq 0xbc10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/crypt/aes128.c
// Function: AES128_CBC_encrypt_buffer
void AES128_CBC_encrypt_buffer(uint8_t* output, uint8_t* input, uint32_t length, const uint8_t* key, const uint8_t* iv)
{
  uintptr_t i;
  uint8_t remainders = length % KEYLEN; /* Remaining bytes in the last non-full block */

  BlockCopy(output, input);
  state = (state_t*)output;

  // Skip the key expansion if key is passed as 0
  if(0 != key)
  {
    Key = key;
    KeyExpansion();
  }

  if(iv != 0)
  {
    Iv = (uint8_t*)iv;
  }

  for(i = 0; i < length; i += KEYLEN)
  {
    XorWithIv(input);
    BlockCopy(output, input);
    state = (state_t*)output;
    Cipher();
    Iv = output;
    input += KEYLEN;
    output += KEYLEN;
  }

  if(remainders)
  {
    BlockCopy(output, input);
    memset(output + remainders, 0, KEYLEN - remainders); /* add 0-padding */
    state = (state_t*)output;
    Cipher();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
andl $0xf, %eax
movb %al, -0x31(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb570
movq -0x8(%rbp), %rax
movq %rax, 0x6cc4(%rip)      # 0x12660
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0xb9b4
movq -0x20(%rbp), %rax
movq %rax, 0x6cb9(%rip)      # 0x12668
callq 0xb5b0
cmpq $0x0, -0x28(%rbp)
je 0xb9c6
movq -0x28(%rbp), %rax
movq %rax, 0x6caa(%rip)      # 0x12670
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jae 0xba31
movq -0x10(%rbp), %rdi
callq 0xba80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb570
movq -0x8(%rbp), %rax
movq %rax, 0x6c65(%rip)      # 0x12660
callq 0xb850
movq -0x8(%rbp), %rax
movq %rax, 0x6c65(%rip)      # 0x12670
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
jmp 0xb9ce
cmpb $0x0, -0x31(%rbp)
je 0xba76
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb570
movq -0x8(%rbp), %rdi
movzbl -0x31(%rbp), %eax
cltq
addq %rax, %rdi
movzbl -0x31(%rbp), %ecx
movl $0x10, %eax
subl %ecx, %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x31c0
movq -0x8(%rbp), %rax
movq %rax, 0x6bef(%rip)      # 0x12660
callq 0xb850
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/crypt/aes128.c
// Function: AES128_CBC_decrypt_buffer
void AES128_CBC_decrypt_buffer(uint8_t* output, uint8_t* input, uint32_t length, const uint8_t* key, const uint8_t* iv)
{
  uintptr_t i;
  uint8_t remainders = length % KEYLEN; /* Remaining bytes in the last non-full block */
  
  BlockCopy(output, input);
  state = (state_t*)output;

  // Skip the key expansion if key is passed as 0
  if(0 != key)
  {
    Key = key;
    KeyExpansion();
  }

  // If iv is passed as 0, we continue to encrypt without re-setting the Iv
  if(iv != 0)
  {
    Iv = (uint8_t*)iv;
  }

  for(i = 0; i < length; i += KEYLEN)
  {
    BlockCopy(output, input);
    state = (state_t*)output;
    InvCipher();
    XorWithIv(output);
    Iv = input;
    input += KEYLEN;
    output += KEYLEN;
  }

  if(remainders)
  {
    BlockCopy(output, input);
    memset(output+remainders, 0, KEYLEN - remainders); /* add 0-padding */
    state = (state_t*)output;
    InvCipher();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x14(%rbp), %eax
andl $0xf, %eax
movb %al, -0x31(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb570
movq -0x8(%rbp), %rax
movq %rax, 0x6b54(%rip)      # 0x12660
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0xbb24
movq -0x20(%rbp), %rax
movq %rax, 0x6b49(%rip)      # 0x12668
callq 0xb5b0
cmpq $0x0, -0x28(%rbp)
je 0xbb36
movq -0x28(%rbp), %rax
movq %rax, 0x6b3a(%rip)      # 0x12670
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jae 0xbba1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb570
movq -0x8(%rbp), %rax
movq %rax, 0x6afe(%rip)      # 0x12660
callq 0xb900
movq -0x8(%rbp), %rdi
callq 0xba80
movq -0x10(%rbp), %rax
movq %rax, 0x6af5(%rip)      # 0x12670
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
jmp 0xbb3e
cmpb $0x0, -0x31(%rbp)
je 0xbbe6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb570
movq -0x8(%rbp), %rdi
movzbl -0x31(%rbp), %eax
cltq
addq %rax, %rdi
movzbl -0x31(%rbp), %ecx
movl $0x10, %eax
subl %ecx, %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x31c0
movq -0x8(%rbp), %rax
movq %rax, 0x6a7f(%rip)      # 0x12660
callq 0xb900
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/crypt/aes128.c
// Function: AddRoundKey
static void AddRoundKey(uint8_t round)
{
  uint8_t i,j;
  for(i=0;i<4;++i)
  {
    for(j = 0; j < 4; ++j)
    {
      (*state)[i][j] ^= RoundKey[round * Nb * 4 + i * Nb + j];
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movb $0x0, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
cmpl $0x4, %eax
jge 0xbc90
movb $0x0, -0x3(%rbp)
movzbl -0x3(%rbp), %eax
cmpl $0x4, %eax
jge 0xbc84
movzbl -0x1(%rbp), %eax
shll $0x2, %eax
shll $0x2, %eax
movzbl -0x2(%rbp), %ecx
shll $0x2, %ecx
addl %ecx, %eax
movzbl -0x3(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x6a29(%rip), %rax      # 0x12680
movzbl (%rax,%rcx), %esi
movq 0x69fe(%rip), %rax      # 0x12660
movzbl -0x2(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movzbl -0x3(%rbp), %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movb -0x3(%rbp), %al
addb $0x1, %al
movb %al, -0x3(%rbp)
jmp 0xbc2b
jmp 0xbc86
movb -0x2(%rbp), %al
addb $0x1, %al
movb %al, -0x2(%rbp)
jmp 0xbc1e
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/crypt/aes128.c
// Function: SubBytes
static void SubBytes(void)
{
  uint8_t i, j;
  for(i = 0; i < 4; ++i)
  {
    for(j = 0; j < 4; ++j)
    {
      (*state)[j][i] = getSBoxValue((*state)[j][i]);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
cmpl $0x4, %eax
jge 0xbd12
movb $0x0, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
cmpl $0x4, %eax
jge 0xbd06
movq 0x6997(%rip), %rax      # 0x12660
movzbl -0x2(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movzbl -0x1(%rbp), %ecx
movzbl (%rax,%rcx), %edi
callq 0xbbf0
movb %al, %dl
movq 0x6976(%rip), %rax      # 0x12660
movzbl -0x2(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movzbl -0x1(%rbp), %ecx
movb %dl, (%rax,%rcx)
movb -0x2(%rbp), %al
addb $0x1, %al
movb %al, -0x2(%rbp)
jmp 0xbcb9
jmp 0xbd08
movb -0x1(%rbp), %al
addb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xbcac
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/crypt/aes128.c
// Function: InvShiftRows
static void InvShiftRows(void)
{
  uint8_t temp;

  // Rotate first row 1 columns to right  
  temp=(*state)[3][1];
  (*state)[3][1]=(*state)[2][1];
  (*state)[2][1]=(*state)[1][1];
  (*state)[1][1]=(*state)[0][1];
  (*state)[0][1]=temp;

  // Rotate second row 2 columns to right 
  temp=(*state)[0][2];
  (*state)[0][2]=(*state)[2][2];
  (*state)[2][2]=temp;

  temp=(*state)[1][2];
  (*state)[1][2]=(*state)[3][2];
  (*state)[3][2]=temp;

  // Rotate third row 3 columns to right
  temp=(*state)[0][3];
  (*state)[0][3]=(*state)[1][3];
  (*state)[1][3]=(*state)[2][3];
  (*state)[2][3]=(*state)[3][3];
  (*state)[3][3]=temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x6635(%rip), %rax      # 0x12660
movb 0xd(%rax), %al
movb %al, -0x1(%rbp)
movq 0x6628(%rip), %rax      # 0x12660
movb 0x9(%rax), %cl
movq 0x661e(%rip), %rax      # 0x12660
movb %cl, 0xd(%rax)
movq 0x6614(%rip), %rax      # 0x12660
movb 0x5(%rax), %cl
movq 0x660a(%rip), %rax      # 0x12660
movb %cl, 0x9(%rax)
movq 0x6600(%rip), %rax      # 0x12660
movb 0x1(%rax), %cl
movq 0x65f6(%rip), %rax      # 0x12660
movb %cl, 0x5(%rax)
movb -0x1(%rbp), %cl
movq 0x65e9(%rip), %rax      # 0x12660
movb %cl, 0x1(%rax)
movq 0x65df(%rip), %rax      # 0x12660
movb 0x2(%rax), %al
movb %al, -0x1(%rbp)
movq 0x65d2(%rip), %rax      # 0x12660
movb 0xa(%rax), %cl
movq 0x65c8(%rip), %rax      # 0x12660
movb %cl, 0x2(%rax)
movb -0x1(%rbp), %cl
movq 0x65bb(%rip), %rax      # 0x12660
movb %cl, 0xa(%rax)
movq 0x65b1(%rip), %rax      # 0x12660
movb 0x6(%rax), %al
movb %al, -0x1(%rbp)
movq 0x65a4(%rip), %rax      # 0x12660
movb 0xe(%rax), %cl
movq 0x659a(%rip), %rax      # 0x12660
movb %cl, 0x6(%rax)
movb -0x1(%rbp), %cl
movq 0x658d(%rip), %rax      # 0x12660
movb %cl, 0xe(%rax)
movq 0x6583(%rip), %rax      # 0x12660
movb 0x3(%rax), %al
movb %al, -0x1(%rbp)
movq 0x6576(%rip), %rax      # 0x12660
movb 0x7(%rax), %cl
movq 0x656c(%rip), %rax      # 0x12660
movb %cl, 0x3(%rax)
movq 0x6562(%rip), %rax      # 0x12660
movb 0xb(%rax), %cl
movq 0x6558(%rip), %rax      # 0x12660
movb %cl, 0x7(%rax)
movq 0x654e(%rip), %rax      # 0x12660
movb 0xf(%rax), %cl
movq 0x6544(%rip), %rax      # 0x12660
movb %cl, 0xb(%rax)
movb -0x1(%rbp), %cl
movq 0x6537(%rip), %rax      # 0x12660
movb %cl, 0xf(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/snow1eo[P]IPsec_IKEv2/crypt/aes128.c
// Function: InvSubBytes
static void InvSubBytes(void)
{
  uint8_t i,j;
  for(i=0;i<4;++i)
  {
    for(j=0;j<4;++j)
    {
      (*state)[j][i] = getSBoxInvert((*state)[j][i]);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
cmpl $0x4, %eax
jge 0xc1a2
movb $0x0, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
cmpl $0x4, %eax
jge 0xc196
movq 0x6507(%rip), %rax      # 0x12660
movzbl -0x2(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movzbl -0x1(%rbp), %ecx
movzbl (%rax,%rcx), %edi
callq 0xcda0
movb %al, %dl
movq 0x64e6(%rip), %rax      # 0x12660
movzbl -0x2(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movzbl -0x1(%rbp), %ecx
movb %dl, (%rax,%rcx)
movb -0x2(%rbp), %al
addb $0x1, %al
movb %al, -0x2(%rbp)
jmp 0xc149
jmp 0xc198
movb -0x1(%rbp), %al
addb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xc13c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/main.c
// Function: cat_char
unsigned char* cat_char(unsigned char** R, size_t d, size_t *n){

  (*n)++; //add 0 at the end

  int_t i, j;
  int_t l=0;
  unsigned char *str = (unsigned char*) malloc((*n)*sizeof(unsigned char));

  for(i=0; i<d; i++){
    int_t m = strlen((char*)R[i]);
    for(j=0; j<m; j++){
      if(R[i][j]<255) str[l++] = R[i][j]+1;
    }
#if CAT == 1
    str[l++] = 1; //add 1 as separator
#endif
  }

  str[l++]=0;
  if(*n>l){
    str = (unsigned char*) realloc(str, (l)*sizeof(unsigned char)); 
  }
  *n = l;

return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
shlq $0x0, %rdi
callq 0xb6a0
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x245b
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x20b0
movl %eax, -0x34(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x244b
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xff, %eax
jge 0x243e
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
addl $0x1, %eax
movb %al, %dl
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x2440
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x23ed
jmp 0x244d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x23c4
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x2496
movq -0x30(%rbp), %rdi
movslq -0x24(%rbp), %rsi
shlq $0x0, %rsi
callq 0xb990
movq %rax, -0x30(%rbp)
movslq -0x24(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/main.c
// Function: usage
void usage(char *name){
  printf("lyndon-array:\n\tUsage: %s [options] FILE \n\n",name);
  puts("Computes the Lyndon-array of FILE");
  puts("Output:\tLyndon-array (and Suffix-array)\n");
  puts("Available options:");
  puts("\t-A a\tpreferred algorithm to use (default 10)");
  puts("\t-d D\tuse the first D documents of the INPUT");
  puts("\t-b\tread INPUT as binary input (default)");
  puts("\t-f\tread INPUT as formatted input (txt, fasta or fastq)");
  puts("\t-v\tverbose output");
  puts("\t-o\toutput computed arrays to disk (INPUT.la and INPUT.sa)");
  puts("\t-s\tcompute some statistics for LA");
  puts("\t-l\toutput the lyndon-factors (start positions) to (INPUT.pos)");
  puts("\t-L\toutput the lyndon-factors (substrings) to (INPUT.lyn)");
  puts("Debug options:");
  puts("\t-c\tcheck output (for debug)");
  puts("\t-p P\tprint the output arrays LA[1,P] and SA[1,P] (for debug)");
  puts("\t-h\tthis help message");
  exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x9c75(%rip), %rdi      # 0xc13c
movb $0x0, %al
callq 0x20e0
leaq 0x9c92(%rip), %rdi      # 0xc167
callq 0x2070
leaq 0x9ca8(%rip), %rdi      # 0xc189
callq 0x2070
leaq 0x9cc5(%rip), %rdi      # 0xc1b2
callq 0x2070
leaq 0x9ccc(%rip), %rdi      # 0xc1c5
callq 0x2070
leaq 0x9cee(%rip), %rdi      # 0xc1f3
callq 0x2070
leaq 0x9d0f(%rip), %rdi      # 0xc220
callq 0x2070
leaq 0x9d2c(%rip), %rdi      # 0xc249
callq 0x2070
leaq 0x9d58(%rip), %rdi      # 0xc281
callq 0x2070
leaq 0x9d5f(%rip), %rdi      # 0xc294
callq 0x2070
leaq 0x9d8e(%rip), %rdi      # 0xc2cf
callq 0x2070
leaq 0x9da5(%rip), %rdi      # 0xc2f2
callq 0x2070
leaq 0x9dd8(%rip), %rdi      # 0xc331
callq 0x2070
leaq 0x9e06(%rip), %rdi      # 0xc36b
callq 0x2070
leaq 0x9e09(%rip), %rdi      # 0xc37a
callq 0x2070
leaq 0x9e1a(%rip), %rdi      # 0xc397
callq 0x2070
leaq 0x9e4c(%rip), %rdi      # 0xc3d5
callq 0x2070
movl $0x1, %edi
callq 0x2250
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/file.c
// Function: clean_filename_ext
const char *clean_filename_ext(const char *filename) {

    char *dot = strrchr(filename, '.');

    *dot = '\0';

    if(!dot || dot == filename) return "";

    return filename;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x2110
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x4056
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x4063
leaq 0x85cd(%rip), %rax      # 0xc62a
movq %rax, -0x8(%rbp)
jmp 0x406b
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)