LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/fft.c
// Function: coswndw
float	*coswndw(int n, float w) {
     int   j, n1;
     float t, dt, *wndw;
     if ( (wndw=(float *)malloc(n*sizeof(float))) == NULL ) return NULL;
     for(j=0;j<n;j++) wndw[j]=1.;
     if (w>0.5) w=0.5;
     n1 = rint(w*n); if (n1<1) n1=1;
     t = 0.;
     dt = PI/n1;
     for(j=0;j<n1;j++,t+=dt) {
        wndw[j]=wndw[n-j-1]=0.5*(1-cos(t));
     }
     return wndw;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1130
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x3984
movq $0x0, -0x8(%rbp)
jmp 0x3aa1
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x39b3
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movss 0x5035(%rip), %xmm0     # 0x89d8
movss %xmm0, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x398b
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x5004(%rip), %xmm1     # 0x89c8
ucomisd %xmm1, %xmm0
jbe 0x39d7
movss 0x4682(%rip), %xmm0     # 0x8054
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
cvtsi2ssl -0xc(%rbp), %xmm1
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1120
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jge 0x3a02
movl $0x1, -0x18(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
cvtsi2sdl -0x18(%rbp), %xmm1
movsd 0x4f99(%rip), %xmm0     # 0x89b0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x3a99
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x10d0
movsd 0x45ff(%rip), %xmm1     # 0x8048
subsd %xmm0, %xmm1
movsd 0x4f73(%rip), %xmm0     # 0x89c8
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
subl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movss -0x20(%rbp), %xmm0
addss -0x1c(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
jmp 0x3a2b
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/fft.c
// Function: findMax
int findMax(float *a, int n, float *amp) {
    int i,shift=0;
    *amp = 0.;
    for(i=0;i<n;i++) {
       if (a[i]>*amp) {
          *amp = a[i];
          shift = i;
       }
    }
    return shift;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3d5e
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x18(%rbp), %rax
ucomiss (%rax), %xmm0
jbe 0x3d51
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x3d53
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3d18
movl -0x20(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/fft.c
// Function: findMaxAbs
int findMaxAbs(float *a, int n, float *amp) {
    int i,shift=0;
    *amp = 0.;
    for(i=0;i<n;i++) {
       if (fabs(a[i])>fabs(*amp)) {
          *amp = a[i]; 
          shift = i;
       }
    }
    return shift;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3e01
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movaps 0x42a8(%rip), %xmm1     # 0x8060
pand %xmm1, %xmm0
movq -0x18(%rbp), %rax
movss (%rax), %xmm1
cvtss2sd %xmm1, %xmm1
movaps 0x4291(%rip), %xmm2     # 0x8060
pand %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3df4
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x3df6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3d98
movl -0x20(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/fft.c
// Function: rtrend
void	rtrend(float *y, int n) {
     int i;
     double a, b, a11, a12, a22, y1, y2;
     y1 = y2 = 0.;
     for(i=0;i<n;i++) {
       y1 += i*y[i];
       y2 += y[i];
     }
     a12 = 0.5*n*(n-1);
     a11 = a12*(2*n-1)/3.;
     a22 = n;
     b = a11*a22-a12*a12;
     a = (a22*y1-a12*y2)/b; 
     b = (a11*y2-a12*y1)/b;
     for(i=0;i<n;i++) {
       y[i] = y[i] - a*i - b;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3e80
cvtsi2ssl -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
mulss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3e32
cvtsi2sdl -0xc(%rbp), %xmm1
movsd 0x4b3b(%rip), %xmm0     # 0x89c8
mulsd %xmm1, %xmm0
movl -0xc(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movl -0xc(%rbp), %eax
shll %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
movsd 0x4b0f(%rip), %xmm1     # 0x89d0
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd -0x48(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x48(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd -0x40(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3ff0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0x10(%rbp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
subsd -0x20(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3f8d
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/fft.c
// Function: fltGauss
void fltGauss(complex *u, int n, float gauss) {
    int j;
    float w, delw, agg;
    delw=PI/n;
    for(w=delw,j=1;j<n;j++,w+=delw) {
	agg = 0.5*w/gauss;
	u[j] = dmltp(exp(-agg*agg),u[j]);
    }
    agg = 0.5*w/gauss;
    u[0].y = (exp(-agg*agg))*u[0].y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm1
movsd 0x498f(%rip), %xmm0     # 0x89b0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x40ee
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x496c(%rip), %xmm1     # 0x89c8
mulsd %xmm1, %xmm0
movss -0x10(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x38(%rbp)
movss -0x20(%rbp), %xmm1
movaps %xmm1, %xmm0
movaps 0x495b(%rip), %xmm2     # 0x89f0
pxor %xmm2, %xmm0
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1210
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
callq 0x4750
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movlpd %xmm0, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movss -0x1c(%rbp), %xmm0
addss -0x18(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
jmp 0x403f
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x48c9(%rip), %xmm0     # 0x89c8
mulsd %xmm1, %xmm0
movss -0x10(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
mulss -0x20(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1210
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x4(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/fft.c
// Function: GaussLP
void GaussLP(float *u, int n, float gauss) {
    int i, nft2;
    complex *v;
    nft2 = 2; while (nft2<n) nft2 *= 2; nft2 /= 2;
    v = (complex *) malloc(nft2*sizeof(complex));
    for(i=0;i<nft2;i++) v[i] = Zero;
    memcpy(v, u, n*sizeof(float));
    fftr(v, nft2, 1.);
    fltGauss(v, nft2, gauss);
    fftr(v, nft2, -1.);
    memcpy(u, v, n*sizeof(float));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movl $0x2, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x418d
movl -0x18(%rbp), %eax
shll %eax
movl %eax, -0x18(%rbp)
jmp 0x417b
movl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movslq -0x18(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1130
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x41f6
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x38(%rbp)
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x48c0
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movlpd %xmm0, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x41b3
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
shlq $0x2, %rdx
callq 0x1110
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
movss 0x47be(%rip), %xmm0     # 0x89d8
callq 0x2760
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
movss -0x10(%rbp), %xmm0
callq 0x4000
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
movss 0x479d(%rip), %xmm0     # 0x89dc
callq 0x2760
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0xc(%rbp), %rdx
shlq $0x2, %rdx
callq 0x1110
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/fft.c
// Function: shiftSpec
void shiftSpec(complex *u, int n, float shift) {
    int j;
    float w, delw;
    delw=PI/n;
    for(w=delw,j=1;j<n;j++,w+=delw) {
	u[j] = cmltp(cmplx(cos(w*shift),-sin(w*shift)),u[j]);
    }
    u[0].y = cos(w*shift)*u[0].y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm1
movsd 0x46ef(%rip), %xmm0     # 0x89b0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x439c
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x40(%rbp)
movss -0x18(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x10d0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x44(%rbp)
movss -0x18(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1190
movaps %xmm0, %xmm1
movss -0x44(%rbp), %xmm0
movaps 0x46bf(%rip), %xmm2     # 0x8a00
pxor %xmm2, %xmm1
cvtsd2ss %xmm1, %xmm1
callq 0x48c0
movlpd %xmm0, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd -0x2c(%rbp), %xmm0
movsd (%rax,%rcx,8), %xmm1
callq 0x4640
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movlpd %xmm0, -0x24(%rbp)
movq -0x24(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movss -0x1c(%rbp), %xmm0
addss -0x18(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
jmp 0x42df
movss -0x18(%rbp), %xmm0
mulss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x10d0
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x4(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/fft.c
// Function: specPwr
float specPwr(complex *u, int n) {
  int j;
  float a, temp;
  for(a=0.,j=0;j<n;j++) {
     temp = ccabs(u[j]);
     a += temp*temp;
  }
  return (a/n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4448
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x4880
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
movss -0x18(%rbp), %xmm2
movss -0x14(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x43fe
movss -0x14(%rbp), %xmm0
cvtsi2ssl -0xc(%rbp), %xmm1
divss %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/Complex.c
// Function: cmltp
complex cmltp(complex a, complex b) {
  complex c;
  c.x = a.x*b.x - a.y*b.y;
  c.y = a.x*b.y + a.y*b.x;
  return(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x18(%rbp)
movss -0x10(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
movss -0x18(%rbp), %xmm2
movss -0x14(%rbp), %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x18(%rbp), %xmm3
movss -0x14(%rbp), %xmm2
movss -0x10(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/Complex.c
// Function: Csqrt
complex Csqrt(complex a) {
  double mo, ar;
  double ccabs(complex);
  mo = sqrt(ccabs(a));
  ar = 0.5*atan2(a.y, a.x);
  a.x = mo*cos(ar);
  a.y = mo*sin(ar);
  return(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movlpd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x4880
callq 0x11f0
movsd %xmm0, -0x18(%rbp)
movss -0x10(%rbp), %xmm1
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
cvtss2sd %xmm1, %xmm1
callq 0x1150
movsd 0x41b8(%rip), %xmm1     # 0x89c8
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x10d0
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x10(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x1190
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/Complex.c
// Function: cmplx
complex cmplx(float x, float y) {
  complex a;
  a.x = x;
  a.y = y;
  return(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/sacio.c
// Function: read_sachead
int	read_sachead(const char	*name,
		SACHEAD		*hd
	)
{
  FILE		*strm;

  if ((strm = fopen(name, "rb")) == NULL) {
     fprintf(stderr, "Unable to open %s\n",name);
     return -1;
  }

  if (fread(hd, sizeof(SACHEAD), 1, strm) != 1) {
     fprintf(stderr, "Error in reading SAC header %s\n",name);
     fclose(strm);
     return -1;
  }

#ifdef BYTE_SWAP
  swab4((char *) hd, HD_SIZE);
#endif

  fclose(strm);
  return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x40b5(%rip), %rsi      # 0x8a50
callq 0x1180
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x49cf
movq 0x6647(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x4094(%rip), %rsi      # 0x8a53
movb $0x0, %al
callq 0x1100
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4a2a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movl $0x278, %esi            # imm = 0x278
movl $0x1, %edx
callq 0x1070
cmpq $0x1, %rax
je 0x4a1a
movq 0x6605(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x4065(%rip), %rsi      # 0x8a66
movb $0x0, %al
callq 0x1100
movq -0x20(%rbp), %rdi
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4a2a
movq -0x20(%rbp), %rdi
callq 0x1090
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/sacio.c
// Function: read_sac
float*	read_sac(const char	*name,
		SACHEAD		*hd
	)
{
  FILE		*strm;
  float		*ar;
  unsigned	sz;

  if ((strm = fopen(name, "rb")) == NULL) {
     fprintf(stderr, "Unable to open %s\n",name);
     return NULL;
  }

  if (fread(hd, sizeof(SACHEAD), 1, strm) != 1) {
     fprintf(stderr, "Error in reading SAC header %s\n",name);
     return NULL;
  }

#ifdef BYTE_SWAP
  swab4((char *) hd, HD_SIZE);
#endif

  sz = hd->npts*sizeof(float);
  if ((ar = (float *) malloc(sz)) == NULL) {
     fprintf(stderr, "Error in allocating memory for reading %s\n",name);
     return NULL;
  }

  if (fread((char *) ar, sz, 1, strm) != 1) {
     fprintf(stderr, "Error in reading SAC data %s\n",name);
     return NULL;
  }

  fclose(strm);

#ifdef BYTE_SWAP
  swab4((char *) ar, sz);
#endif

  return ar;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3ff5(%rip), %rsi      # 0x8a50
callq 0x1180
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x4a93
movq 0x6587(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3fd4(%rip), %rsi      # 0x8a53
movb $0x0, %al
callq 0x1100
movq $0x0, -0x8(%rbp)
jmp 0x4b79
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movl $0x278, %esi            # imm = 0x278
movl $0x1, %edx
callq 0x1070
cmpq $0x1, %rax
je 0x4ad9
movq 0x6541(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3fa1(%rip), %rsi      # 0x8a66
movb $0x0, %al
callq 0x1100
movq $0x0, -0x8(%rbp)
jmp 0x4b79
movq -0x18(%rbp), %rax
movslq 0x13c(%rax), %rax
shlq $0x2, %rax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %edi
callq 0x1130
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x4b25
movq 0x64f2(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3f72(%rip), %rsi      # 0x8a86
movb $0x0, %al
callq 0x1100
movq $0x0, -0x8(%rbp)
jmp 0x4b79
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
movq -0x20(%rbp), %rcx
movl $0x1, %edx
callq 0x1070
cmpq $0x1, %rax
je 0x4b68
movq 0x64af(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3f5a(%rip), %rsi      # 0x8ab1
movb $0x0, %al
callq 0x1100
movq $0x0, -0x8(%rbp)
jmp 0x4b79
movq -0x20(%rbp), %rdi
callq 0x1090
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/sacio.c
// Function: swab4
void	swab4(	char	*pt,
		int	n
	)
{
  int i;
  char temp;
  for(i=0;i<n;i+=4) {
    temp = pt[i+3];
    pt[i+3] = pt[i];
    pt[i] = temp;
    temp = pt[i+2];
    pt[i+2] = pt[i+1];
    pt[i+1] = temp;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4dfe
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x11(%rbp), %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x11(%rbp), %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x10(%rbp)
jmp 0x4d62
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/sacio.c
// Function: sachdr
SACHEAD    sachdr( float dt, int ns, float b0)
{
  SACHEAD	hd = sac_null;
  hd.npts = ns;
  hd.delta = dt;
  hd.b = b0;
  hd.o = 0.;
  hd.e = b0+(ns-1)*hd.delta;
  hd.iztype = IO;
  hd.iftype = ITIME;
  hd.leven = TRUE;
  return hd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movss %xmm0, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
leaq 0x61e9(%rip), %rsi      # 0xb010
movl $0x278, %edx            # imm = 0x278
callq 0x1110
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl -0x8(%rbp), %ecx
movl %ecx, 0x13c(%rdi)
movss -0x4(%rbp), %xmm0
movss %xmm0, (%rdi)
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x14(%rdi)
xorps %xmm0, %xmm0
movss %xmm0, 0x1c(%rdi)
movss -0xc(%rbp), %xmm1
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
cvtsi2ss %ecx, %xmm0
movss (%rdi), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x18(%rdi)
movl $0xb, 0x15c(%rdi)
movl $0x1, 0x154(%rdi)
movl $0x1, 0x1a4(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/sacio.c
// Function: wrtsac2
int	wrtsac2(const char	*name,
		int		n,
		const float	*x,
		const float	*y
	)
{
  SACHEAD	hd = sac_null;
  float		*ar;
  unsigned	sz;
  int		exit_code;

  hd.npts = n;
  hd.iftype = IXY;
  hd.leven = FALSE;

  sz = n*sizeof(float);

  if ( (ar = (float *) malloc(2*sz)) == NULL ) {
     fprintf(stderr, "error in allocating memory%s\n",name);
     return -1;
  }

  if (memcpy(ar, x, sz) == NULL) {
     fprintf(stderr, "error in copying data %s\n",name);
     free(ar);
     return -1;
  }
  if (memcpy(ar+sz, y, sz) == NULL) {
     fprintf(stderr, "error in copying data %s\n",name);
     free(ar);
     return -1;
  }

  exit_code = write_sac(name, hd, ar);
  
  free(ar);
  
  return exit_code;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x550, %rsp            # imm = 0x550
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x2a0(%rbp), %rdi
leaq 0x6138(%rip), %rsi      # 0xb010
movl $0x278, %edx            # imm = 0x278
callq 0x1110
movl -0x14(%rbp), %eax
movl %eax, -0x164(%rbp)
movl $0x4, -0x14c(%rbp)
movl $0x0, -0xfc(%rbp)
movslq -0x14(%rbp), %rax
shlq $0x2, %rax
movl %eax, -0x2ac(%rbp)
movl -0x2ac(%rbp), %eax
shll %eax
movl %eax, %eax
movl %eax, %edi
callq 0x1130
movq %rax, -0x2a8(%rbp)
cmpq $0x0, %rax
jne 0x4f53
movq 0x60c6(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3c5e(%rip), %rsi      # 0x8b9e
movb $0x0, %al
callq 0x1100
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5076
movq -0x2a8(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
movq -0x20(%rbp), %rsi
movl -0x2ac(%rbp), %eax
movl %eax, %edx
callq 0x1110
movq -0x2b8(%rbp), %rax
cmpq $0x0, %rax
jne 0x4fb3
movq 0x6072(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3c28(%rip), %rsi      # 0x8bbc
movb $0x0, %al
callq 0x1100
movq -0x2a8(%rbp), %rdi
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5076
movq -0x2a8(%rbp), %rdi
movl -0x2ac(%rbp), %eax
shlq $0x2, %rax
addq %rax, %rdi
movq %rdi, -0x2c0(%rbp)
movq -0x28(%rbp), %rsi
movl -0x2ac(%rbp), %eax
movl %eax, %edx
callq 0x1110
movq -0x2c0(%rbp), %rax
cmpq $0x0, %rax
jne 0x501d
movq 0x6005(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3bbb(%rip), %rsi      # 0x8bbc
movb $0x0, %al
callq 0x1100
movq -0x2a8(%rbp), %rdi
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5076
movq -0x10(%rbp), %rax
movq %rax, -0x2c8(%rbp)
movq -0x2a8(%rbp), %rax
movq %rax, -0x2d0(%rbp)
movq %rsp, %rdi
movl $0x4f, %ecx
leaq -0x2a0(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq -0x2d0(%rbp), %rsi
movq -0x2c8(%rbp), %rdi
callq 0x4b90
movl %eax, -0x2b0(%rbp)
movq -0x2a8(%rbp), %rdi
callq 0x1040
movl -0x2b0(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x550, %rsp            # imm = 0x550
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/sacio.c
// Function: rdsac0_
void rdsac0_(const char *name, float *dt, int *ns, float *b0, float *ar) {
   int i;
   SACHEAD hd;
   float *temp;
   temp = read_sac(name,&hd);
   *dt = hd.delta;
   *ns = hd.npts;
   *b0 = hd.b;
   for(i=0;i<*ns;i++) ar[i]=temp[i];
   free(temp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2a4(%rbp), %rsi
callq 0x4a40
movq %rax, -0x2b0(%rbp)
movss -0x2a4(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movl -0x168(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movss -0x290(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x512c
movq -0x2b0(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x50f9
movq -0x2b0(%rbp), %rdi
callq 0x1040
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/sacio.c
// Function: wrtsac0_
void    wrtsac0_(const char *name, float *dt, int *ns, float *b0, float *dist, const float *ar) {
  SACHEAD hd;
  hd = sachdr(*dt,*ns,*b0);
  hd.dist = *dist;
  write_sac(name, hd, ar);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7b0, %rsp            # imm = 0x7B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rax
movss (%rax), %xmm1
leaq -0x520(%rbp), %rdi
callq 0x4e00
leaq -0x2a8(%rbp), %rdi
leaq -0x520(%rbp), %rsi
movl $0x278, %edx            # imm = 0x278
callq 0x1110
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x1e0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x528(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x530(%rbp)
movq %rsp, %rdi
movl $0x4f, %ecx
leaq -0x2a8(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq -0x530(%rbp), %rsi
movq -0x528(%rbp), %rdi
callq 0x4b90
addq $0x7b0, %rsp            # imm = 0x7B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/sacio.c
// Function: wrtsac1_
void    wrtsac1_(const char *name, float *dt, int *ns, float *b0,float *tp,float *ts, float *dist, float *az, float *user1, const float *ar) {
  SACHEAD hd;
  hd = sachdr(*dt,*ns,*b0);
  hd.gcarc = *dist;
  hd.az = *az;
  hd.t3 = *b0+30;
  hd.t1 = *tp+30;
  hd.t2 = *ts+30;
  hd.o = 0.;
  hd.user1 = *user1;
  write_sac(name, hd, ar);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7b0, %rsp            # imm = 0x7B0
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rax
movss (%rax), %xmm1
leaq -0x520(%rbp), %rdi
callq 0x4e00
leaq -0x2a8(%rbp), %rdi
leaq -0x520(%rbp), %rsi
movl $0x278, %edx            # imm = 0x278
callq 0x1110
movq 0x10(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x1d4(%rbp)
movq 0x18(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x1dc(%rbp)
movq -0x20(%rbp), %rax
movss 0x379b(%rip), %xmm0     # 0x8a44
addss (%rax), %xmm0
movss %xmm0, -0x274(%rbp)
movq -0x28(%rbp), %rax
movss 0x3783(%rip), %xmm0     # 0x8a44
addss (%rax), %xmm0
movss %xmm0, -0x27c(%rbp)
movq -0x30(%rbp), %rax
movss 0x376b(%rip), %xmm0     # 0x8a44
addss (%rax), %xmm0
movss %xmm0, -0x278(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x28c(%rbp)
movq 0x20(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x204(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x528(%rbp)
movq 0x28(%rbp), %rax
movq %rax, -0x530(%rbp)
movq %rsp, %rdi
movl $0x4f, %ecx
leaq -0x2a8(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq -0x530(%rbp), %rsi
movq -0x528(%rbp), %rdi
callq 0x4b90
addq $0x7b0, %rsp            # imm = 0x7B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/sacio.c
// Function: wrtsac3_
void    wrtsac3_(const char *name, float dt, int ns, float b0, float dist, float cmpaz, float cmpinc, const float *ar) {
  SACHEAD hd;
  hd = sachdr(dt,ns,b0);
  hd.dist = dist;
  hd.cmpaz=cmpaz;
  hd.cmpinc=cmpinc;
  write_sac(name, hd, ar);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a0, %rsp            # imm = 0x7A0
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movss %xmm1, -0x14(%rbp)
movss %xmm2, -0x18(%rbp)
movss %xmm3, -0x1c(%rbp)
movss %xmm4, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movss -0xc(%rbp), %xmm0
movl -0x10(%rbp), %esi
movss -0x14(%rbp), %xmm1
leaq -0x518(%rbp), %rdi
callq 0x4e00
leaq -0x2a0(%rbp), %rdi
leaq -0x518(%rbp), %rsi
movl $0x278, %edx            # imm = 0x278
callq 0x1110
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x1d8(%rbp)
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x1bc(%rbp)
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x1b8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x520(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x528(%rbp)
movq %rsp, %rdi
movl $0x4f, %ecx
leaq -0x2a0(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq -0x528(%rbp), %rsi
movq -0x520(%rbp), %rdi
callq 0x4b90
addq $0x7a0, %rsp            # imm = 0x7A0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/sacio.c
// Function: ResetSacTime
void ResetSacTime(SACHEAD *hd) {
     hd->o = 0.;
     hd->a = 0.;
     hd->nzyear = -12345;
     hd->nzjday = -12345;
     hd->nzhour = -12345;
     hd->nzmin = -12345;
     hd->nzsec = -12345;
     hd->nzmsec = -12345;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1c(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0xffffcfc7, 0x118(%rax) # imm = 0xFFFFCFC7
movq -0x8(%rbp), %rax
movl $0xffffcfc7, 0x11c(%rax) # imm = 0xFFFFCFC7
movq -0x8(%rbp), %rax
movl $0xffffcfc7, 0x120(%rax) # imm = 0xFFFFCFC7
movq -0x8(%rbp), %rax
movl $0xffffcfc7, 0x124(%rax) # imm = 0xFFFFCFC7
movq -0x8(%rbp), %rax
movl $0xffffcfc7, 0x128(%rax) # imm = 0xFFFFCFC7
movq -0x8(%rbp), %rax
movl $0xffffcfc7, 0x12c(%rax) # imm = 0xFFFFCFC7
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/YunyiQian[P]multitel3/radiats.c
// Function: sf_radiat
void	sf_radiat(float stk,float dip,float rad[4][3]) {
   float sstk,sdip,cstk,cdip;
   stk*=DEG2RAD; dip*=DEG2RAD;
   sstk=sin(stk);cstk=cos(stk);
   sdip=sin(dip);cdip=cos(dip);
   rad[0][0]=-sdip;
   rad[0][1]=rad[0][0];
   rad[0][2]=0.;
   rad[1][0]=cdip*cstk;
   rad[1][1]=rad[1][0];
   rad[1][2]=cdip*sstk;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x30c1(%rip), %xmm1     # 0x8c38
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x30a3(%rip), %xmm1     # 0x8c38
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1190
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x10d0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1190
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x10d0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x18(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
movss -0x20(%rbp), %xmm0
mulss -0x1c(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0xc(%rax)
movq -0x10(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x10(%rax)
movss -0x20(%rbp), %xmm0
mulss -0x14(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c0stya[P]fslib/src/fsdraw.c
// Function: file_open
FILE * file_open(const char * filename) { 
    FILE * s;
    if (( s = fopen(filename, "r")) == NULL ) {
        fprintf(stderr, "Error opening file: %s\n", filename);
        exit(EXIT_FAILURE);
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x11f3(%rip), %rsi      # 0x80fa
callq 0x1160
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x6f3c
movq 0x40db(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x11d1(%rip), %rsi      # 0x80fc
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1190
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]disputils/ppd.c
// Function: main
int
main(int argc, char *argv[])
{
#ifdef __OpenBSD__
	if (pledge("stdio rpath unix", NULL) == -1)
		err(1, "pledge");
#endif
	xcb_randr_get_output_primary_reply_t *primary_output;

	if (argc > 1)
		usage(argv[0]);
	init_xcb(&conn);
	get_screen(conn, &scrn);

	primary_output = get_primary_output(conn);

	printf("%s\n", get_output_name(conn, primary_output->output));
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x1368
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1310
leaq 0x2db1(%rip), %rdi      # 0x4120
callq 0x13d0
movq 0x2da5(%rip), %rdi      # 0x4120
leaq 0x2da6(%rip), %rsi      # 0x4128
callq 0x1450
movq 0x2d92(%rip), %rdi      # 0x4120
callq 0x1810
movq %rax, -0x18(%rbp)
movq 0x2d82(%rip), %rdi      # 0x4120
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x1610
movq %rax, %rsi
leaq 0xc5c(%rip), %rdi       # 0x2010
movb $0x0, %al
callq 0x10b0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/./fileio.c
// Function: read_file
void *read_file(char *name, size_t *length) {
    void *mem = NULL;
    FILE *fh = NULL;
    struct stat s;
    size_t len;

    if (!stat(name, &s)) {
        if (S_ISDIR(s.st_mode)) {
            errno = EISDIR;
        }
        else {
            len = (size_t) s.st_size;
            if ((mem = malloc(len)) &&
                (fh = fopen(name, "rb")) &&
                fread(mem, 1, len, fh) == len)
            {
                if (length) *length = len;
                fclose(fh);
                return mem;
            }
        }
    }

    if (mem) free(mem);
    if (fh) fclose(fh);
    perror(name);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x10f0
cmpl $0x0, %eax
jne 0x135a
movl -0xa0(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x12ce
callq 0x1050
movl $0x15, (%rax)
jmp 0x1358
movq -0x88(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rdi
callq 0x1110
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1356
movq -0x10(%rbp), %rdi
leaq 0x2d07(%rip), %rsi      # 0x4004
callq 0x1120
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1356
movq -0x20(%rbp), %rdi
movq -0xc0(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x1070
cmpq -0xc0(%rbp), %rax
jne 0x1356
cmpq $0x0, -0x18(%rbp)
je 0x1343
movq -0xc0(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x1090
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x138b
jmp 0x1358
jmp 0x135a
cmpq $0x0, -0x20(%rbp)
je 0x136a
movq -0x20(%rbp), %rdi
callq 0x1030
cmpq $0x0, -0x28(%rbp)
je 0x137a
movq -0x28(%rbp), %rdi
callq 0x1090
movq -0x10(%rbp), %rdi
callq 0x1130
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/./fileio.c
// Function: write_file
int write_file(char *name, void *mem, size_t length) {
    FILE *fh;
    int ok = 0;
    if ((fh = fopen(name, "wb"))) {
        ok = (fwrite(mem, 1, length, fh) == length);
        fclose(fh);
    }
    if (!ok) {
        perror(name);
    }
    return ok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2c41(%rip), %rsi      # 0x4007
callq 0x1120
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1403
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x1150
cmpq -0x18(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1090
cmpl $0x0, -0x24(%rbp)
jne 0x1412
movq -0x8(%rbp), %rdi
callq 0x1130
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/dumpamos.c
// Function: output_fname
char *output_fname(char *fname, char *fmt, ...) {
    size_t namelen = strlen(fname), i;
    char *name = malloc(namelen + 202);
    va_list args;

    if (!name) {
        perror(fname);
        return NULL;
    }

    *name = 0;
    if (use_prefix) {
        /* prefix input filename, with .amos/.abk/.abs stripped off */
        char *extensions[] = {".amos", ".abk", ".abs"};
        strcpy(name, fname);
        for (i = 0; i < sizeof(extensions)/sizeof(*extensions); i++) {
            size_t elen = strlen(extensions[i]);
            if (namelen > elen && !strcasecmp(&name[namelen - elen], extensions[i])) {
                name[namelen - elen] = 0;
                break;
            }
        }
        /* append "." */
        strcat(name, ".");
    }
    va_start(args, fmt);
    vsnprintf(&name[strlen(name)], 200, fmt, args);
    va_end(args);
    return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
testb %al, %al
je 0x1467
movaps %xmm0, -0x100(%rbp)
movaps %xmm1, -0xf0(%rbp)
movaps %xmm2, -0xe0(%rbp)
movaps %xmm3, -0xd0(%rbp)
movaps %xmm4, -0xc0(%rbp)
movaps %xmm5, -0xb0(%rbp)
movaps %xmm6, -0xa0(%rbp)
movaps %xmm7, -0x90(%rbp)
movq %r9, -0x108(%rbp)
movq %r8, -0x110(%rbp)
movq %rcx, -0x118(%rbp)
movq %rdx, -0x120(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0xca, %rdi
callq 0x1110
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x14c9
movq -0x10(%rbp), %rdi
callq 0x1130
movq $0x0, -0x8(%rbp)
jmp 0x15ea
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x0, 0x4bf5(%rip)      # 0x60cc
je 0x158a
movq 0x48ec(%rip), %rax      # 0x5dd0
movq %rax, -0x70(%rbp)
movq 0x48e9(%rip), %rax      # 0x5dd8
movq %rax, -0x68(%rbp)
movq 0x48e6(%rip), %rax      # 0x5de0
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1060
movq $0x0, -0x28(%rbp)
cmpq $0x3, -0x28(%rbp)
jae 0x157a
movq -0x28(%rbp), %rax
movq -0x70(%rbp,%rax,8), %rdi
callq 0x10a0
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x78(%rbp), %rax
jbe 0x156a
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
subq -0x78(%rbp), %rax
addq %rax, %rdi
movq -0x28(%rbp), %rax
movq -0x70(%rbp,%rax,8), %rsi
callq 0x1040
cmpl $0x0, %eax
jne 0x156a
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
subq -0x78(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x157a
jmp 0x156c
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1513
movq -0x30(%rbp), %rdi
leaq 0x2bd1(%rip), %rsi      # 0x4156
callq 0x1140
leaq -0x50(%rbp), %rax
leaq -0x130(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x30(%rbp), %rdi
callq 0x10a0
movq -0x138(%rbp), %rdi
addq %rax, %rdi
movq -0x18(%rbp), %rdx
leaq -0x50(%rbp), %rcx
movl $0xc8, %esi
callq 0x1080
leaq -0x50(%rbp), %rax
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/dumpamos.c
// Function: bank_number
uint32_t bank_number(uint8_t *src, size_t len) {
    if (len >= 6 && amos_leek(src) == ID_AmSp) {
        return 1; /* Sprites always bank 1 */
    }
    if (len >= 6 && amos_leek(src) == ID_AmIc) {
        return 2; /* Icons always bank 2 */
    }
    if (len >= 20 && amos_leek(src) == ID_AmBk) {
        return amos_deek(&src[4]);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x6, -0x18(%rbp)
jb 0x1894
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
shll $0x18, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
orl %ecx, %eax
cmpl $0x416d5370, %eax       # imm = 0x416D5370
jne 0x1894
movl $0x1, -0x4(%rbp)
jmp 0x1936
cmpq $0x6, -0x18(%rbp)
jb 0x18d9
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
shll $0x18, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
orl %ecx, %eax
cmpl $0x416d4963, %eax       # imm = 0x416D4963
jne 0x18d9
movl $0x2, -0x4(%rbp)
jmp 0x1936
cmpq $0x14, -0x18(%rbp)
jb 0x192f
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
shll $0x18, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
orl %ecx, %eax
cmpl $0x416d426b, %eax       # imm = 0x416D426B
jne 0x192f
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1936
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/dumpamos.c
// Function: bank_type
char *bank_type(uint8_t *src, size_t len) {
    if (len >= 6 && amos_leek(src) == ID_AmSp) {
        return "Sprites";
    }
    if (len >= 6 && amos_leek(src) == ID_AmIc) {
        return "Icons";
    }
    if (len >= 20 && amos_leek(src) == ID_AmBk) {
        /* copy bank type, remove space padding */
        static char type[9];
        char *tp = &type[8];
        memcpy(type, &src[12], 8);
        do { *tp-- = 0; } while (*tp == ' ' && tp > &type[0]);
        return type;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x6, -0x18(%rbp)
jb 0x1998
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
shll $0x18, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
orl %ecx, %eax
cmpl $0x416d5370, %eax       # imm = 0x416D5370
jne 0x1998
leaq 0x2686(%rip), %rax      # 0x4015
movq %rax, -0x8(%rbp)
jmp 0x1a92
cmpq $0x6, -0x18(%rbp)
jb 0x19e4
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
shll $0x18, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
orl %ecx, %eax
cmpl $0x416d4963, %eax       # imm = 0x416D4963
jne 0x19e4
leaq 0x2642(%rip), %rax      # 0x401d
movq %rax, -0x8(%rbp)
jmp 0x1a92
cmpq $0x14, -0x18(%rbp)
jb 0x1a8a
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
shll $0x18, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
orl %ecx, %eax
cmpl $0x416d426b, %eax       # imm = 0x416D426B
jne 0x1a8a
leaq 0x46a5(%rip), %rax      # 0x60d0
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xc(%rax), %rax
movq %rax, 0x468e(%rip)      # 0x60d0
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x20, %ecx
movb %al, -0x21(%rbp)
jne 0x1a76
leaq 0x4664(%rip), %rax      # 0x60d0
cmpq %rax, -0x20(%rbp)
seta %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1a42
leaq 0x464c(%rip), %rax      # 0x60d0
movq %rax, -0x8(%rbp)
jmp 0x1a92
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/dumpamos.c
// Function: decode_tracker
void decode_tracker(char *fname, uint8_t *src, size_t len) {
    uint32_t mod_len = len - 20;
    char *outname = output_fname(fname, "tracker%02X.mod", bank_number(src, len));
    if (outname) {
        printf("%s: extracting tracker mod %s (%d bytes)\n", fname, outname, mod_len);
        write_file(outname, &src[20], mod_len);
        free(outname);
    }
    else {
        perror(fname);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
subq $0x14, %rax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1840
movq -0x30(%rbp), %rdi
movl %eax, %edx
leaq 0x1568(%rip), %rsi      # 0x4109
movb $0x0, %al
callq 0x1420
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2bed
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq 0x1554(%rip), %rdi      # 0x4119
movb $0x0, %al
callq 0x10b0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x14, %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x13a0
movq -0x28(%rbp), %rdi
callq 0x1030
jmp 0x2bf6
movq -0x8(%rbp), %rdi
callq 0x1130
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)