LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/sds.c
// Function: sdsnewlen
sds sdsnewlen(const void *init, size_t initlen) {
    struct sdshdr *sh;

    if (init) {
        sh = zmalloc(sizeof(struct sdshdr)+initlen+1);
    } else {
        sh = zcalloc(sizeof(struct sdshdr)+initlen+1);
    }
    if (sh == NULL) return NULL;
    sh->len = initlen;
    sh->free = 0;
    if (initlen && init)
        memcpy(sh->buf, init, initlen);
    sh->buf[initlen] = '\0';
    return (char*)sh->buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9d9e
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
addq $0x1, %rdi
callq 0x10ce0
movq %rax, -0x20(%rbp)
jmp 0x9db3
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
addq $0x1, %rdi
callq 0x10d90
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9dc4
movq $0x0, -0x8(%rbp)
jmp 0x9e17
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x9dfe
cmpq $0x0, -0x10(%rbp)
je 0x9dfe
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4240
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, 0x8(%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/sds.c
// Function: sdsMakeRoomFor
sds sdsMakeRoomFor(sds s, size_t addlen) {
    struct sdshdr *sh, *newsh;
    size_t free = sdsavail(s);
    size_t len, newlen;

    if (free >= addlen) return s;
    len = sdslen(s);
    sh = (void*) (s-(sizeof(struct sdshdr)));
    newlen = (len+addlen);
    if (newlen < SDS_MAX_PREALLOC)
        newlen *= 2;
    else
        newlen += SDS_MAX_PREALLOC;
    newsh = zrealloc(sh, sizeof(struct sdshdr)+newlen+1);
    if (newsh == NULL) return NULL;

    newsh->free = newlen - len;
    return newsh->buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9d50
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x9fc4
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa055
movq -0x10(%rbp), %rdi
callq 0x9d30
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x100000, -0x40(%rbp)  # imm = 0x100000
jae 0xa000
movq -0x40(%rbp), %rax
shlq %rax
movq %rax, -0x40(%rbp)
jmp 0xa00e
movq -0x40(%rbp), %rax
addq $0x100000, %rax         # imm = 0x100000
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
addq $0x1, %rsi
callq 0x10e40
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xa038
movq $0x0, -0x8(%rbp)
jmp 0xa055
movq -0x40(%rbp), %rax
subq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/sds.c
// Function: sdsIncrLen
void sdsIncrLen(sds s, int incr) {
    struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));

    assert(sh->free >= incr);
    sh->len += incr;
    sh->free -= incr;
    assert(sh->free >= 0);
    s[sh->len] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jl 0xa109
jmp 0xa128
leaq 0x8978(%rip), %rdi      # 0x12a88
leaq 0x8982(%rip), %rsi      # 0x12a99
movl $0x9c, %edx
leaq 0x897c(%rip), %rcx      # 0x12a9f
callq 0x4180
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0xa14e
jmp 0xa16d
leaq 0x8964(%rip), %rdi      # 0x12ab9
leaq 0x893d(%rip), %rsi      # 0x12a99
movl $0x9f, %edx
leaq 0x8937(%rip), %rcx      # 0x12a9f
callq 0x4180
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/ziplist.c
// Function: ziplistIndex
unsigned char *ziplistIndex(unsigned char *zl, int index) {
    unsigned char *p;
    zlentry entry;
    if (index < 0) {
        index = (-index)-1;
        p = ZIPLIST_ENTRY_TAIL(zl);
        if (p[0] != ZIP_END) {
            entry = zipEntry(p);
            while (entry.prevrawlen > 0 && index--) {
                p -= entry.prevrawlen;
                entry = zipEntry(p);
            }
        }
    } else {
        p = ZIPLIST_ENTRY_HEAD(zl);
        while (p[0] != ZIP_END && index--) {
            p += zipRawEntryLength(p);
        }
    }
    return (p[0] == ZIP_END || index > 0) ? NULL : p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0xeb1a
xorl %eax, %eax
subl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
je 0xeb18
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xebb0
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x34(%rbp)
movb %al, -0x79(%rbp)
jbe 0xeac7
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0x79(%rbp)
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0xead0
jmp 0xeb16
movl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0xebb0
movq -0x78(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xeaa8
jmp 0xeb18
jmp 0xeb73
movq -0x8(%rbp), %rax
addq $0xa, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xff, %ecx
movb %al, -0x7a(%rbp)
je 0xeb4e
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0x7a(%rbp)
movb -0x7a(%rbp), %al
testb $0x1, %al
jne 0xeb57
jmp 0xeb71
movq -0x18(%rbp), %rdi
callq 0xeda0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0xeb26
jmp 0xeb73
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
je 0xeb87
cmpl $0x0, -0xc(%rbp)
jle 0xeb92
xorl %eax, %eax
movq %rax, -0x88(%rbp)
jmp 0xeb9d
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/ziplist.c
// Function: zipEntry
static zlentry zipEntry(unsigned char *p) {
    zlentry e;

    ZIP_DECODE_PREVLEN(p, e.prevrawlensize, e.prevrawlen);
    ZIP_DECODE_LENGTH(p + e.prevrawlensize, e.encoding, e.lensize, e.len);
    e.headersize = e.prevrawlensize + e.lensize;
    e.p = p;
    return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
jmp 0xebc6
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xfe, %eax
jge 0xebe0
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
jmp 0xebea
movq -0x18(%rbp), %rax
movl $0x5, (%rax)
jmp 0xebec
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xec05
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movl %ecx, 0x4(%rax)
jmp 0xec1e
movq -0x18(%rbp), %rax
cmpl $0x5, (%rax)
jne 0xec1c
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x1(%rcx), %ecx
movl %ecx, 0x4(%rax)
jmp 0xec1e
jmp 0xec20
jmp 0xec22
jmp 0xec24
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rax), %edx
movb (%rcx,%rdx), %cl
movb %cl, 0x14(%rax)
movzbl 0x14(%rax), %eax
cmpl $0xc0, %eax
jge 0xec50
movq -0x18(%rbp), %rax
movzbl 0x14(%rax), %ecx
andl $0xc0, %ecx
movb %cl, 0x14(%rax)
jmp 0xec52
movq -0x18(%rbp), %rax
movzbl 0x14(%rax), %eax
cmpl $0xc0, %eax
jge 0xed5a
movq -0x18(%rbp), %rax
movzbl 0x14(%rax), %eax
cmpl $0x0, %eax
jne 0xec92
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rcx
movl (%rax), %edx
movzbl (%rcx,%rdx), %ecx
andl $0x3f, %ecx
movl %ecx, 0xc(%rax)
jmp 0xed58
movq -0x18(%rbp), %rax
movzbl 0x14(%rax), %eax
cmpl $0x40, %eax
jne 0xeccf
movq -0x18(%rbp), %rax
movl $0x2, 0x8(%rax)
movq -0x8(%rbp), %rcx
movl (%rax), %edx
movzbl (%rcx,%rdx), %ecx
andl $0x3f, %ecx
shll $0x8, %ecx
movq -0x8(%rbp), %rdx
movl (%rax), %esi
movzbl 0x1(%rdx,%rsi), %edx
orl %edx, %ecx
movl %ecx, 0xc(%rax)
jmp 0xed56
movq -0x18(%rbp), %rax
movzbl 0x14(%rax), %eax
cmpl $0x80, %eax
jne 0xed29
movq -0x18(%rbp), %rax
movl $0x5, 0x8(%rax)
movq -0x8(%rbp), %rcx
movl (%rax), %edx
movzbl 0x1(%rcx,%rdx), %ecx
shll $0x18, %ecx
movq -0x8(%rbp), %rdx
movl (%rax), %esi
movzbl 0x2(%rdx,%rsi), %edx
shll $0x10, %edx
orl %edx, %ecx
movq -0x8(%rbp), %rdx
movl (%rax), %esi
movzbl 0x3(%rdx,%rsi), %edx
shll $0x8, %edx
orl %edx, %ecx
movq -0x8(%rbp), %rdx
movl (%rax), %esi
movzbl 0x4(%rdx,%rsi), %edx
orl %edx, %ecx
movl %ecx, 0xc(%rax)
jmp 0xed54
xorl %eax, %eax
testb $0x1, %al
jne 0xed31
jmp 0xed33
jmp 0xed52
leaq 0x3e7d(%rip), %rdi      # 0x12bb7
leaq 0x3e2f(%rip), %rsi      # 0x12b70
movl $0x17d, %edx            # imm = 0x17D
leaq 0x3faf(%rip), %rcx      # 0x12cfc
callq 0x4180
jmp 0xed54
jmp 0xed56
jmp 0xed58
jmp 0xed77
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
movzbl 0x14(%rax), %edi
callq 0xfab0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0xed79
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %edx
addl 0x8(%rcx), %edx
movl %edx, 0x10(%rcx)
movq -0x8(%rbp), %rdx
movq %rdx, 0x18(%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/ziplist.c
// Function: ziplistGet
unsigned int ziplistGet(unsigned char *p, unsigned char **sstr, unsigned int *slen, long long *sval) {
    zlentry entry;
    if (p == NULL || p[0] == ZIP_END) return 0;
    if (sstr) *sstr = NULL;

    entry = zipEntry(p);
    if (ZIP_IS_STR(entry.encoding)) {
        if (sstr) {
            *slen = entry.len;
            *sstr = p+entry.headersize;
        }
    } else {
        if (sval) {
            *sval = zipLoadInteger(p+entry.headersize,entry.encoding);
        }
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf09d
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
jne 0xf0a9
movl $0x0, -0x4(%rbp)
jmp 0xf148
cmpq $0x0, -0x18(%rbp)
je 0xf0bb
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0xebb0
movq -0x68(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movzbl -0x34(%rbp), %eax
andl $0xc0, %eax
cmpl $0xc0, %eax
jge 0xf11b
cmpq $0x0, -0x18(%rbp)
je 0xf119
movl -0x3c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movl -0x38(%rbp), %eax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xf141
cmpq $0x0, -0x28(%rbp)
je 0xf13f
movq -0x10(%rbp), %rdi
movl -0x38(%rbp), %eax
addq %rax, %rdi
movzbl -0x34(%rbp), %esi
callq 0xf160
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0xf141
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/zmalloc.c
// Function: zmalloc_size
size_t zmalloc_size(void *ptr) {
    void *realptr = (char*)ptr-PREFIX_SIZE;
    size_t size = *((size_t*)realptr);
    /* Assume at least that all the allocations are padded at sizeof(long) by
     * the underlying allocator. */
    if (size&(sizeof(long)-1)) size += sizeof(long)-(size&(sizeof(long)-1));
    return size+PREFIX_SIZE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x10fd5
movq -0x18(%rbp), %rcx
andq $0x7, %rcx
movl $0x8, %eax
subq %rcx, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DAMASKER/REPmask.c
// Function: EVENT_SORT
static int EVENT_SORT(const void *l, const void *r)
{ Event *x = ((Event *) l);
  Event *y = ((Event *) r);

  if (x->pos != y->pos)
    return (x->pos - y->pos);
  return (x->add - y->add);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4(%rcx), %eax
je 0x42bf
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
subl 0x4(%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x42ce
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/finalize.c
// Function: main
int
main(void)
{
    int me, npes;
    struct utsname u;

    uname(&u);

    shmem_init();

    me = shmem_my_pe();
    npes = shmem_n_pes();

    printf("%s: %4d / %4d: Hello\n", u.nodename, me, npes);

    shmem_finalize();

    printf("%s: %4d / %4d: OpenSHMEM finalized, but can do other things\n",
           u.nodename, me, npes);

    shmem_finalize();

    return 0;
}

// Assembly:
subq $0x198, %rsp            # imm = 0x198
movl $0x0, 0x194(%rsp)
leaq 0x6(%rsp), %rdi
callq 0x1040
callq 0x1080
callq 0x1070
movl %eax, 0x190(%rsp)
callq 0x1050
movl %eax, 0x18c(%rsp)
leaq 0x6(%rsp), %rsi
addq $0x41, %rsi
movl 0x190(%rsp), %edx
movl 0x18c(%rsp), %ecx
leaq 0xe1d(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
callq 0x1060
leaq 0x6(%rsp), %rsi
addq $0x41, %rsi
movl 0x190(%rsp), %edx
movl 0x18c(%rsp), %ecx
leaq 0xe09(%rip), %rdi       # 0x201a
movb $0x0, %al
callq 0x1030
callq 0x1060
xorl %eax, %eax
addq $0x198, %rsp            # imm = 0x198
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv4/ref/blake2b.c
// Function: blake2b_init
int blake2b_init(blake2b_ctx *ctx, size_t outlen,
    const void *key, size_t keylen)        // (keylen=0: no key)
{
    size_t i;

    if (outlen == 0 || outlen > 64 || keylen > 64)
        return -1;                      // illegal parameters

    for (i = 0; i < 8; i++)             // state, "param block"
        ctx->h[i] = blake2b_iv[i];
    ctx->h[0] ^= 0x01010000 ^ (keylen << 8) ^ outlen;

    ctx->t[0] = 0;                      // input count low word
    ctx->t[1] = 0;                      // input count high word
    ctx->c = 0;                         // pointer within buffer
    ctx->outlen = outlen;

    for (i = keylen; i < 128; i++)      // zero input block
        ctx->b[i] = 0;
    if (keylen > 0) {
        blake2b_update(ctx, key, keylen);
        ctx->c = 128;                   // at the end
    }

    return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1230
cmpq $0x40, 0x20(%rsp)
ja 0x1230
cmpq $0x40, 0x10(%rsp)
jbe 0x123d
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x1350
movq $0x0, 0x8(%rsp)
cmpq $0x8, 0x8(%rsp)
jae 0x1280
movq 0x8(%rsp), %rcx
leaq 0x6da6(%rip), %rax      # 0x8000
movq (%rax,%rcx,8), %rdx
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rdx, 0x80(%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1246
movq 0x10(%rsp), %rcx
shlq $0x8, %rcx
xorq $0x1010000, %rcx        # imm = 0x1010000
xorq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
xorq 0x80(%rax), %rcx
movq %rcx, 0x80(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0xc0(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0xc8(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0xd0(%rax)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0xd8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x80, 0x8(%rsp)
jae 0x131c
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x12f3
cmpq $0x0, 0x10(%rsp)
jbe 0x1348
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1050
movq 0x28(%rsp), %rax
movq $0x80, 0xd0(%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv4/ref/blake2b.c
// Function: blake2b_update
void blake2b_update(blake2b_ctx *ctx,
    const void *in, size_t inlen)       // data bytes
{
    size_t i;

    for (i = 0; i < inlen; i++) {
        if (ctx->c == 128) {            // buffer full ?
            ctx->t[0] += ctx->c;        // add counters
            if (ctx->t[0] < ctx->c)     // carry overflow ?
                ctx->t[1]++;            // high word
            blake2b_compress(ctx, 0);   // compress (not last)
            ctx->c = 0;                 // counter to zero
        }
        ctx->b[ctx->c++] = ((const uint8_t *) in)[i];
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x144c
movq 0x20(%rsp), %rax
cmpq $0x80, 0xd0(%rax)
jne 0x140a
movq 0x20(%rsp), %rax
movq 0xd0(%rax), %rcx
movq 0x20(%rsp), %rax
addq 0xc0(%rax), %rcx
movq %rcx, 0xc0(%rax)
movq 0x20(%rsp), %rax
movq 0xc0(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0xd0(%rcx), %rax
jae 0x13ee
movq 0x20(%rsp), %rax
movq 0xc8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xc8(%rax)
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x1460
movq 0x20(%rsp), %rax
movq $0x0, 0xd0(%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x20(%rsp), %rax
movq 0x20(%rsp), %rsi
movq 0xd0(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0xd0(%rsi)
movb %dl, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x137c
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv4/ref/blake2b.c
// Function: blake2b_final
void blake2b_final(blake2b_ctx *ctx, void *out)
{
    size_t i;

    ctx->t[0] += ctx->c;                // mark last block offset
    if (ctx->t[0] < ctx->c)             // carry overflow
        ctx->t[1]++;                    // high word

    while (ctx->c < 128)                // fill up with zeros
        ctx->b[ctx->c++] = 0;
    blake2b_compress(ctx, 1);           // final block flag = 1

    // little endian convert and store
    for (i = 0; i < ctx->outlen; i++) {
        ((uint8_t *) out)[i] =
            (ctx->h[i >> 3] >> (8 * (i & 7))) & 0xFF;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0xd0(%rax), %rcx
movq 0x10(%rsp), %rax
addq 0xc0(%rax), %rcx
movq %rcx, 0xc0(%rax)
movq 0x10(%rsp), %rax
movq 0xc0(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0xd0(%rcx), %rax
jae 0x22ee
movq 0x10(%rsp), %rax
movq 0xc8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xc8(%rax)
jmp 0x22f0
movq 0x10(%rsp), %rax
cmpq $0x80, 0xd0(%rax)
jae 0x2327
movq 0x10(%rsp), %rax
movq 0x10(%rsp), %rdx
movq 0xd0(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0xd0(%rdx)
movb $0x0, (%rax,%rcx)
jmp 0x22f0
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x1460
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0xd8(%rcx), %rax
jae 0x2396
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
shrq $0x3, %rcx
movq 0x80(%rax,%rcx,8), %rax
movq (%rsp), %rcx
andq $0x7, %rcx
shlq $0x3, %rcx
shrq %cl, %rax
andq $0xff, %rax
movb %al, %dl
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movb %dl, (%rax,%rcx)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x233e
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv4/ref/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
    unsigned char *c,unsigned long long *clen,
    const unsigned char *m,unsigned long long mlen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *nsec,
    const unsigned char *npub,
    const unsigned char *k
)
{
    byte *AD[] = {(byte*)ad};
    unsigned adbytes[] = {(unsigned)adlen};
    (void)nsec;
    if (clen) *clen = mlen+16;
    Encrypt((byte*)k, 48, (byte*)npub, 12, AD,
                adbytes, 1, 16, (byte*)m, mlen, (byte*)c);
    return 0;
}

// Assembly:
subq $0x68, %rsp
movq 0x80(%rsp), %rax
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movl %eax, 0x2c(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x2d50
movq 0x48(%rsp), %rcx
addq $0x10, %rcx
movq 0x58(%rsp), %rax
movq %rcx, (%rax)
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rdx
leaq 0x30(%rsp), %r8
leaq 0x2c(%rsp), %r9
movq 0x50(%rsp), %r11
movq 0x48(%rsp), %rax
movl %eax, %r10d
movq 0x60(%rsp), %rax
movl $0x30, %esi
movl $0xc, %ecx
movl $0x1, (%rsp)
movl $0x10, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x10d0
xorl %eax, %eax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv4/ref/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
    unsigned char *m,unsigned long long *mlen,
    unsigned char *nsec,
    const unsigned char *c,unsigned long long clen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *npub,
    const unsigned char *k
)
{
    byte *AD[] = {(byte*)ad};
    unsigned adbytes[] = {(unsigned)adlen};
    (void)nsec;
    if (mlen) *mlen = clen-16;
    return Decrypt((byte*)k, 48, (byte*)npub, 12, AD,
                    adbytes, 1, 16, (byte*)c, clen, (byte*)m);
}

// Assembly:
subq $0x68, %rsp
movq 0x80(%rsp), %rax
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x70(%rsp), %rax
movl %eax, 0x2c(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x2e10
movq 0x40(%rsp), %rcx
subq $0x10, %rcx
movq 0x58(%rsp), %rax
movq %rcx, (%rax)
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rdx
leaq 0x30(%rsp), %r8
leaq 0x2c(%rsp), %r9
movq 0x48(%rsp), %r11
movq 0x40(%rsp), %rax
movl %eax, %r10d
movq 0x60(%rsp), %rax
movl $0x30, %esi
movl $0xc, %ecx
movl $0x1, (%rsp)
movl $0x10, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x1030
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv4/ref/encrypt.c
// Function: mult_block
static void mult_block(unsigned x, byte *src, byte *dst) {
    byte t[16], r[16];
    memcpy(t,src,16); memset(r,0,16);
    while (x != 0) {
        if (x&1) xor_bytes(r,t,16,r);
        double_block(t);
        x>>=1;
    }
    memcpy(dst,r,16);
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1040
cmpl $0x0, 0x34(%rsp)
je 0x3665
movl 0x34(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x364f
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
movq %rsp, %rcx
movl $0x10, %edx
callq 0x34d0
leaq 0x10(%rsp), %rdi
callq 0x3680
movl 0x34(%rsp), %eax
shrl %eax
movl %eax, 0x34(%rsp)
jmp 0x3627
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aezv4/ref/encrypt.c
// Function: double_block
static void double_block(byte *p) {
    byte i, tmp = p[0];
    for (i=0; i<15; i++)
        p[i] = (p[i] << 1) | (p[i+1] >> 7);
    p[15] = (p[15] << 1) ^ ((tmp >> 7)?135:0);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movb (%rax), %al
movb %al, -0xa(%rsp)
movb $0x0, -0x9(%rsp)
movzbl -0x9(%rsp), %eax
cmpl $0xf, %eax
jge 0x36e3
movq -0x8(%rsp), %rax
movzbl -0x9(%rsp), %ecx
movzbl (%rax,%rcx), %eax
shll %eax
movq -0x8(%rsp), %rcx
movzbl -0x9(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
sarl $0x7, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movzbl -0x9(%rsp), %ecx
movb %dl, (%rax,%rcx)
movb -0x9(%rsp), %al
addb $0x1, %al
movb %al, -0x9(%rsp)
jmp 0x3695
movq -0x8(%rsp), %rax
movzbl 0xf(%rax), %eax
shll %eax
movzbl -0xa(%rsp), %esi
sarl $0x7, %esi
xorl %ecx, %ecx
movl $0x87, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0xf(%rax)
retq
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/multisyn.c
// Function: trapezoid
float *trapezoid(float dura, float rise, float dt, int *ns) {
   int i, nr;
   float amp, *src;
   *ns = rint(dura/dt); if (*ns<2) *ns = 2;
   src = malloc((1+*ns)*sizeof(float));
   if (src == NULL) {*ns=0; return src;}
   nr = rint(rise*(*ns)); if (nr<1) nr = 1; if (2*nr>*ns) nr=*ns/2;
   amp = 1./(nr*(*ns-nr));
   for(i=0;i<nr;i++) src[i] = i*amp;
   for(;i<*ns-nr;i++) src[i] = nr*amp;
   for(;i<=*ns;i++)   src[i] = (*ns-i)*amp;
   (*ns)++;
   return src;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movq %rdi, -0x20(%rbp)
movss -0xc(%rbp), %xmm0
divss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1120
cvttsd2si %xmm0, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jge 0x228b
movq -0x20(%rbp), %rax
movl $0x2, (%rax)
movq -0x20(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1130
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x22c2
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x23e5
movss -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
cvtsi2ssl (%rax), %xmm1
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1120
cvttsd2si %xmm0, %eax
movl %eax, -0x28(%rbp)
cmpl $0x1, -0x28(%rbp)
jge 0x22f0
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %eax
shll %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x230e
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
subl -0x28(%rbp), %ecx
imull %ecx, %eax
cvtsi2sd %eax, %xmm1
movsd 0x5d1f(%rip), %xmm0     # 0x8048
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x2367
cvtsi2ssl -0x24(%rbp), %xmm0
mulss -0x2c(%rbp), %xmm0
movq -0x38(%rbp), %rax
movslq -0x24(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x233d
jmp 0x2369
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
subl -0x28(%rbp), %ecx
cmpl %ecx, %eax
jge 0x239b
cvtsi2ssl -0x28(%rbp), %xmm0
mulss -0x2c(%rbp), %xmm0
movq -0x38(%rbp), %rax
movslq -0x24(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2369
jmp 0x239d
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x23d2
movq -0x20(%rbp), %rax
movl (%rax), %eax
subl -0x24(%rbp), %eax
cvtsi2ss %eax, %xmm0
mulss -0x2c(%rbp), %xmm0
movq -0x38(%rbp), %rax
movslq -0x24(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x239d
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/fft.c
// Function: cor
void	cor(
	    complex	*src,		/* In: source function */
	    complex     *data,		/* In: data */
	                                /* Out: cross-correlation */
	    float	dt,		/* In: dt */
	    int 	nft		/* In: number of pts */
	    )
{
  int	j;
  float	aa;

  data[0]=cmplx(data[0].x*src[0].x, data[0].y*src[0].y);
  for (aa=-1.,j=1; j<nft; j++) {
    data[j]=cmltp(data[j], conjg(src[j]));
    data[j]=dmltp(aa, data[j]);
    aa = -aa;
  }
  fftr(data, nft, -dt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq -0x8(%rbp), %rax
movss (%rcx), %xmm0
movss 0x4(%rcx), %xmm1
movss (%rax), %xmm3
movss 0x4(%rax), %xmm2
mulss %xmm3, %xmm0
mulss %xmm2, %xmm1
callq 0x48c0
movq -0x48(%rbp), %rax
movlpd %xmm0, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movss 0x5de1(%rip), %xmm0     # 0x89dc
movss %xmm0, -0x20(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x2cbe
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movslq -0x1c(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax,%rcx,8), %xmm0
callq 0x47a0
movq -0x68(%rbp), %rcx
movq -0x60(%rbp), %rax
movlpd %xmm0, -0x38(%rbp)
movsd (%rax,%rcx,8), %xmm0
movsd -0x38(%rbp), %xmm1
callq 0x4640
movq -0x68(%rbp), %rcx
movq -0x60(%rbp), %rax
movlpd %xmm0, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movslq -0x1c(%rbp), %rcx
movq %rcx, %rdx
movq %rdx, -0x58(%rbp)
movss -0x20(%rbp), %xmm0
movsd (%rax,%rcx,8), %xmm1
callq 0x4750
movq -0x58(%rbp), %rcx
movq -0x50(%rbp), %rax
movlpd %xmm0, -0x40(%rbp)
movq -0x40(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movss -0x20(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2c07
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movss -0x14(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
callq 0x2760
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/fft.c
// Function: conv
void    conv(float *s, int ns, float *f, int n) {
  int   i,j,k,m;
  float *g,*pt;
  m = n+ns;
  if ( (g=(float *) malloc(m*sizeof(float))) == NULL ) {
     fprintf(stderr, "fail to malloc in conv()\n");
     exit(-1);
  }
  for(i=0;i<ns;i++) g[i] = 0.;
  for(pt=f,k=0;k<n;k++,i++,pt++){
     g[i] = *pt;
     for(*pt=0.,j=0;j<ns;j++) *pt += g[i-j]*s[j];
  }
  free(g);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1130
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x2d48
movq 0x82cb(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x5cd9(%rip), %rsi      # 0x8a10
movb $0x0, %al
callq 0x1100
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x11d0
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2d72
movq -0x38(%rbp), %rax
movslq -0x20(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2d4f
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2e1f
movq -0x40(%rbp), %rax
movss (%rax), %xmm0
movq -0x38(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq -0x40(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2dfa
movq -0x38(%rbp), %rax
movl -0x20(%rbp), %ecx
subl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movq -0x40(%rbp), %rax
movss (%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2db4
jmp 0x2dfc
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x40(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x40(%rbp)
jmp 0x2d81
movq -0x38(%rbp), %rdi
callq 0x1040
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/fft.c
// Function: crscrl
float	*crscrl(int npt,float *rec,float *syn,int m) {
  int	i,nft,nft2;
  float	*ss1,*ss2;
  nft=2;while(nft<npt)nft*=2;nft2=nft;nft*=2;
  ss1=(float *)calloc(nft, sizeof(float));
  ss2=(float *)calloc(nft, sizeof(float));
  memcpy((char *)ss1, (char *) rec, npt*sizeof(float));
  memcpy((char *)ss2, (char *) syn, npt*sizeof(float));
  for(i=npt;i<nft;i++) {ss1[i]=0.;ss2[i]=0.;}
  fftr((complex *) ss1,nft2,1.);
  fftr((complex *) ss2,nft2,1.);

  cor((complex *) ss2, (complex *) ss1, 1., nft2);

  nft2 -= m/2;
  i = (m+1)*sizeof(float);
  ss2=(float *)realloc(ss2, i);
  memcpy(ss2, ss1+nft2, i);
  free(ss1);
  return(ss2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x2, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2e9f
movl -0x24(%rbp), %eax
shll %eax
movl %eax, -0x24(%rbp)
jmp 0x2e8d
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
shll %eax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rdi
movl $0x4, %esi
callq 0x10f0
movq %rax, -0x30(%rbp)
movslq -0x24(%rbp), %rdi
movl $0x4, %esi
callq 0x10f0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x4(%rbp), %rdx
shlq $0x2, %rdx
callq 0x1110
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x4(%rbp), %rdx
shlq $0x2, %rdx
callq 0x1110
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x2f34
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x38(%rbp), %rax
movslq -0x20(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2f01
movq -0x30(%rbp), %rdi
movl -0x28(%rbp), %esi
movss 0x5a95(%rip), %xmm0     # 0x89d8
callq 0x2760
movq -0x38(%rbp), %rdi
movl -0x28(%rbp), %esi
movss 0x5a81(%rip), %xmm0     # 0x89d8
callq 0x2760
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x28(%rbp), %edx
movss 0x5a69(%rip), %xmm0     # 0x89d8
callq 0x2ba0
movl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x28(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x2, %rax
movl %eax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x1170
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movslq -0x20(%rbp), %rdx
callq 0x1110
movq -0x30(%rbp), %rdi
callq 0x1040
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/fft.c
// Function: maxCor
float maxCor(float *data, float *syn, int n, int max_shift, int *delay, float *amp) {
  int	i;
  float	*crs,c,dataAuto,synAuto;
  for(dataAuto=0.,synAuto=0.,i=0;i<n;i++) {
     dataAuto += data[i]*data[i];
     synAuto += syn[i]*syn[i];
  }
  if (max_shift<0) max_shift = n;
  crs = crscrl(n,data,syn,2*max_shift);
  for(c=-FLT_MAX,i=0;i<=2*max_shift;i++) {
     if (c<crs[i]) {
        c=crs[i];
        *delay=i;
     }
  }
  free(crs);
  *delay -= max_shift;
  *amp = c/synAuto;
  return(c/sqrt(dataAuto*synAuto));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x44(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3080
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movss -0x40(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movss -0x44(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x44(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3015
cmpl $0x0, -0x18(%rbp)
jge 0x308c
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x18(%rbp), %ecx
shll %ecx
callq 0x2e70
movq %rax, -0x38(%rbp)
movss 0x5933(%rip), %xmm0     # 0x89e0
movss %xmm0, -0x3c(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl -0x18(%rbp), %ecx
shll %ecx
cmpl %ecx, %eax
jg 0x3104
movss -0x3c(%rbp), %xmm1
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x30f7
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x3c(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x30f9
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x30b9
movq -0x38(%rbp), %rdi
callq 0x1040
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movss -0x3c(%rbp), %xmm0
divss -0x44(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
movss -0x3c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
movss -0x40(%rbp), %xmm0
mulss -0x44(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11f0
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/fft.c
// Function: maxCorSlide
float maxCorSlide(float *data, float *syn, int n, int lw, float overlap,int *delay, float *amp) {
  int	i, j, max_shift, delay0;
  float	cc, cc_best, amp0;
  max_shift = (int) rint(lw*(1.-overlap));
  cc_best = -FLT_MAX;
  for(i=0;i+lw<n;i+=max_shift) {
     for(j=0;j+lw<n;j+=max_shift) {
        cc = maxCor(data+i,syn+j,lw,max_shift,&delay0,&amp0);
	if (cc>cc_best) {
	   cc_best = cc;
	   *delay = delay0 + i-j;
	   *amp = amp0;
	}
     }
  }
  return cc_best;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cvtsi2sdl -0x18(%rbp), %xmm0
movss -0x1c(%rbp), %xmm1
cvtss2sd %xmm1, %xmm2
movsd 0x4e9f(%rip), %xmm1     # 0x8048
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
callq 0x1120
cvttsd2si %xmm0, %eax
movl %eax, -0x3c(%rbp)
movss 0x581b(%rip), %xmm0     # 0x89e0
movss %xmm0, -0x48(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
addl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3276
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
addl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3266
movq -0x8(%rbp), %rdi
movslq -0x34(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x38(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movl -0x18(%rbp), %edx
movl -0x3c(%rbp), %ecx
leaq -0x40(%rbp), %r8
leaq -0x4c(%rbp), %r9
callq 0x2fe0
movss %xmm0, -0x44(%rbp)
movss -0x44(%rbp), %xmm0
ucomiss -0x48(%rbp), %xmm0
jbe 0x3259
movss -0x44(%rbp), %xmm0
movss %xmm0, -0x48(%rbp)
movl -0x40(%rbp), %ecx
addl -0x34(%rbp), %ecx
subl -0x38(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movss -0x4c(%rbp), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x325b
movl -0x3c(%rbp), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x31e7
jmp 0x3268
movl -0x3c(%rbp), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x31d1
movss -0x48(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/fft.c
// Function: acc
float acc(float *data, int n, float t1, float t2, int half) {
  int i;
  float am1, am2, amc;
  int it1 = floor(t1-half);
  int it2 = floor(t2-half);
  int len = 2*half;
  if ( half<1 || it2<it1 || it1<0 || it2+len>n-1 ) return 0.;
  for(am1=0.,am2=0.,amc=0.,i=0; i<len; i++) {
    am1 += data[it1+i]*data[it1+i];
    am2 += data[it2+i]*data[it2+i];
    amc += data[it1+i]*data[it2+i];
  }
  return amc/sqrt(am1*am2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
movss %xmm1, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movss -0x18(%rbp), %xmm0
cvtsi2ssl -0x20(%rbp), %xmm1
subss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11a0
cvttsd2si %xmm0, %eax
movl %eax, -0x34(%rbp)
movss -0x1c(%rbp), %xmm0
cvtsi2ssl -0x20(%rbp), %xmm1
subss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11a0
cvttsd2si %xmm0, %eax
movl %eax, -0x38(%rbp)
movl -0x20(%rbp), %eax
shll %eax
movl %eax, -0x3c(%rbp)
cmpl $0x1, -0x20(%rbp)
jl 0x3524
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jl 0x3524
cmpl $0x0, -0x34(%rbp)
jl 0x3524
movl -0x38(%rbp), %eax
addl -0x3c(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x3531
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x3642
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x360c
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm2
movss -0x28(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl -0x38(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movl -0x38(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm2
movss -0x2c(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movl -0x38(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm2
movss -0x30(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3550
movss -0x30(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
movss -0x28(%rbp), %xmm0
mulss -0x2c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x11f0
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/fft.c
// Function: cumsum
void cumsum(float *a, int n, float dt) {
  int i;
  float u;
  for(u=0,i=0;i<n;i++) {
     u+=a[i]*dt;
     a[i] = u;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x36b8
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss -0x10(%rbp), %xmm2
movss -0x18(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x366f
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/fft.c
// Function: maver
void maver(float *a, int n, int m) {
  int i, j, m2;
  float aver, c, *b;
  m2 = (m-1)/2;
  c = 1./m;
  b = (float *) calloc(n+m-1, sizeof(float));
  memcpy(b+m2, a, n*sizeof(float));
  for(aver=0.,j=m2;j<m;j++) {
     aver += c*b[j];
  }
  a[0] = aver;
  for(i=1;i<n;i++,j++) {
     aver += c*(b[j]-b[j-m]);
     a[i] = aver;
  }
  free(b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
cvtsi2sdl -0x10(%rbp), %xmm1
movsd 0x4958(%rip), %xmm0     # 0x8048
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x10f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
shlq $0x2, %rdx
callq 0x1110
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x377c
movss -0x24(%rbp), %xmm0
movq -0x30(%rbp), %rax
movslq -0x18(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movss -0x20(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3745
movss -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x37f4
movss -0x24(%rbp), %xmm0
movq -0x30(%rbp), %rax
movslq -0x18(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movq -0x30(%rbp), %rax
movl -0x18(%rbp), %ecx
subl -0x10(%rbp), %ecx
movslq %ecx, %rcx
subss (%rax,%rcx,4), %xmm2
movss -0x20(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3790
movq -0x30(%rbp), %rdi
callq 0x1040
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/fft.c
// Function: diffrt
void diffrt(float *a, int n, float dt) {
  int i;
  for(i=n-1;i>0;i--) {
     a[i] = (a[i]-a[i-1])/dt;
  }
  a[0]=0.;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x386b
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
subss (%rax,%rcx,4), %xmm0
divss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3829
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/fft.c
// Function: revers
void revers(float *a, int n) {
   int i, j;
   float dum;
   for(i=0,j=n-1;i<j;i++,j--) {
      dum  = a[i];
      a[i] = a[j];
      a[j] = dum;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3945
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x38eb
popq %rbp
retq
nopw (%rax,%rax)