LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %r15d
movl %edx, %eax
movq %rsi, %rdx
movq %rdi, %rsi
testl %eax, %eax
jle 0x29d9
movl %eax, %ecx
xorps %xmm1, %xmm1
xorl %edi, %edi
xorps %xmm2, %xmm2
movss (%rsi,%rdi,4), %xmm0
mulss %xmm0, %xmm0
addss %xmm0, %xmm2
movss (%rdx,%rdi,4), %xmm0
mulss %xmm0, %xmm0
addss %xmm0, %xmm1
incq %rdi
cmpq %rdi, %rcx
jne 0x29b5
jmp 0x29df
xorps %xmm2, %xmm2
xorps %xmm1, %xmm1
movss %xmm2, 0x14(%rsp)
movss %xmm1, 0x8(%rsp)
testl %r15d, %r15d
cmovsl %eax, %r15d
leal (%r15,%r15), %ebp
movl %eax, %edi
movl %ebp, %ecx
callq 0x2846
testl %r15d, %r15d
js 0x2a2d
movl %ebp, %ecx
incq %rcx
movss 0x3fdb(%rip), %xmm1     # 0x69ec
xorl %edx, %edx
movss (%rax,%rdx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2a23
movl %edx, (%r14)
movaps %xmm0, %xmm1
incq %rdx
cmpq %rdx, %rcx
jne 0x2a13
jmp 0x2a35
movss 0x3fb7(%rip), %xmm1     # 0x69ec
movss %xmm1, 0x10(%rsp)
movq %rax, %rdi
callq 0x1040
subl %r15d, (%r14)
movss 0x10(%rsp), %xmm1
xorps %xmm2, %xmm2
cvtss2sd %xmm1, %xmm2
movss 0x8(%rsp), %xmm0
divss %xmm0, %xmm1
movss %xmm1, (%rbx)
movss 0x14(%rsp), %xmm1
mulss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2a81
sqrtsd %xmm0, %xmm0
jmp 0x2a92
movsd %xmm2, 0x8(%rsp)
callq 0x1220
movsd 0x8(%rsp), %xmm2
divsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
cvtsi2sd %ecx, %xmm1
cvtss2sd %xmm0, %xmm2
movsd 0x359a(%rip), %xmm0     # 0x6078
subsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
callq 0x1150
cmpl %ebx, %ebp
jge 0x2bab
cvttsd2si %xmm0, %r13d
movslq %r13d, %rcx
movl %ebp, 0x4(%rsp)
movslq %ebp, %rax
movslq %ebx, %rdx
subq %rax, %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, %r12
leaq (,%rcx,4), %rax
movq %rax, 0x40(%rsp)
movss 0x3ec7(%rip), %xmm0     # 0x69ec
movss %xmm0, (%rsp)
xorl %ecx, %ecx
movq 0x18(%rsp), %rax
leaq (%rax,%rcx,4), %rbx
movq 0x20(%rsp), %r14
movq %rcx, 0x28(%rsp)
movl %ecx, %r15d
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl 0x4(%rsp), %edx
movl %r13d, %ecx
leaq 0xc(%rsp), %r8
leaq 0x8(%rsp), %r9
callq 0x298c
ucomiss (%rsp), %xmm0
jbe 0x2b88
movl 0xc(%rsp), %eax
addl %r15d, %eax
movq 0x30(%rsp), %rcx
movl %eax, (%rcx)
movss 0x8(%rsp), %xmm1
movq 0x38(%rsp), %rax
movss %xmm1, (%rax)
movss %xmm0, (%rsp)
addq %r12, %rbp
subl %r13d, %r15d
addq 0x40(%rsp), %r14
cmpq 0x10(%rsp), %rbp
jl 0x2b44
movq 0x28(%rsp), %rcx
addq %r12, %rcx
cmpq 0x10(%rsp), %rcx
jl 0x2b2c
jmp 0x2bb8
movss 0x3e39(%rip), %xmm0     # 0x69ec
movss %xmm0, (%rsp)
movss (%rsp), %xmm0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/YunyiQian[P]multitel3/fft.c
// Function: amp
float amp(float t1, float t2, float *data, int n) {
  int i, it1, it2;
  float dd, am;
  if ( t1 < 0 ) t1=0;
  if ( t2 > n-1 ) t2=n-1;
  if ( t1 > n-1 || t2 < t1) return 0.;
  it1 = floor(t1);
  i = it1 + 1;
  dd = i-t1;
  am = dd*(dd*data[it1]+(2.-dd)*data[i]);
/* return data[it1]*dd + data[i]*(1.-dd);*/
  it2 = ceil(t2);
  while (i<it2) {
    am += data[i]+data[i+1];
    i++;
  }
  dd = i-t2;
  am -= dd*(dd*data[i-1]+(2.-dd)*data[i]);
  return 0.5*am;
}

// Assembly:
xorps %xmm3, %xmm3
decl %esi
cvtsi2ss %esi, %xmm2
maxss %xmm0, %xmm3
xorps %xmm0, %xmm0
ucomiss %xmm2, %xmm3
ja 0x2d15
minss %xmm1, %xmm2
ucomiss %xmm2, %xmm3
ja 0x2d15
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movaps %xmm3, %xmm0
movss %xmm2, 0xc(%rsp)
movss %xmm3, 0x8(%rsp)
callq 0x11d0
cvttss2si %xmm0, %eax
leal 0x1(%rax), %ebp
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
subss 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movslq %eax, %r14
mulss (%rbx,%r14,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x3db7(%rip), %xmm2     # 0x69f8
subsd %xmm1, %xmm2
xorps %xmm3, %xmm3
cvtss2sd 0x4(%rbx,%r14,4), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm0, %xmm3
mulsd %xmm1, %xmm3
xorps %xmm0, %xmm0
cvtsd2ss %xmm3, %xmm0
movss %xmm0, 0x8(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x1100
cvttss2si %xmm0, %eax
cmpl %eax, %ebp
jge 0x2cab
decl %eax
movss 0x8(%rsp), %xmm4
movss 0x4(%rbx,%r14,4), %xmm0
addss 0x8(%rbx,%r14,4), %xmm0
addss %xmm0, %xmm4
incq %r14
cmpl %r14d, %eax
jne 0x2c83
incl %r14d
movl %r14d, %ebp
movss 0xc(%rsp), %xmm1
jmp 0x2cb7
movss 0xc(%rsp), %xmm1
movss 0x8(%rsp), %xmm4
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
subss %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movslq %ebp, %rax
mulss -0x4(%rbx,%rax,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x3d1a(%rip), %xmm3     # 0x69f8
subsd %xmm1, %xmm3
xorps %xmm2, %xmm2
cvtss2sd (%rbx,%rax,4), %xmm2
mulsd %xmm3, %xmm2
addsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtss2sd %xmm4, %xmm0
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm0
cvtsd2ss %xmm0, %xmm0
mulss 0x3cdb(%rip), %xmm0     # 0x69e8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movss %xmm1, (%rsp)
movl %esi, %ebp
movq %rdi, %r14
xorps %xmm1, %xmm1
cvtsi2ss %edx, %xmm1
movss %xmm1, 0xc(%rsp)
subss %xmm1, %xmm0
callq 0x11d0
movss %xmm0, 0x8(%rsp)
movss (%rsp), %xmm0
subss 0xc(%rsp), %xmm0
callq 0x11d0
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
testl %ebx, %ebx
jle 0x2e17
cvttss2si 0x8(%rsp), %ecx
cvttss2si %xmm1, %eax
addl %ebx, %ebx
cmpl %ecx, %eax
setge %dl
testl %ecx, %ecx
setns %sil
andb %dl, %sil
leal (%rbx,%rax), %edx
cmpl %ebp, %edx
setl %dl
andb %sil, %dl
cmpb $0x1, %dl
jne 0x2e17
movl %ecx, %ecx
movslq %eax, %rdx
cmpl $0x2, %ebx
movl $0x1, %eax
cmovgel %ebx, %eax
leaq (%r14,%rcx,4), %rcx
leaq (%r14,%rdx,4), %rdx
xorl %esi, %esi
xorps %xmm2, %xmm2
xorps %xmm1, %xmm1
movss (%rcx,%rsi,4), %xmm3
movaps %xmm3, %xmm4
mulss %xmm3, %xmm4
addss %xmm4, %xmm0
movss (%rdx,%rsi,4), %xmm4
mulss %xmm4, %xmm3
mulss %xmm4, %xmm4
addss %xmm4, %xmm1
addss %xmm3, %xmm2
incq %rsi
cmpq %rsi, %rax
jne 0x2db2
cvtss2sd %xmm2, %xmm2
mulss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2dfd
sqrtsd %xmm0, %xmm0
jmp 0x2e0c
movsd %xmm2, (%rsp)
callq 0x1220
movsd (%rsp), %xmm2
divsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %esi, %esi
jle 0x2e45
movl %esi, %eax
xorps %xmm1, %xmm1
xorl %ecx, %ecx
movss (%rdi,%rcx,4), %xmm2
mulss %xmm0, %xmm2
addss %xmm2, %xmm1
movss %xmm1, (%rdi,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x2e2b
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movl %esi, %r15d
movq %rdi, %rbx
leal -0x1(%r12), %eax
shrl $0x1f, %eax
leal (%r12,%rax), %ebp
decl %ebp
sarl %ebp
cvtsi2sd %edx, %xmm0
movsd 0x3202(%rip), %xmm1     # 0x6078
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
leal (%r12,%r15), %eax
decl %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x1110
movq %rax, %r14
movslq %ebp, %r13
leaq (%rax,%r13,4), %rdi
movslq %r15d, %rdx
shlq $0x2, %rdx
movq %rbx, %rsi
callq 0x1130
movss 0x4(%rsp), %xmm2
xorps %xmm0, %xmm0
movslq %r12d, %rax
cmpl %r12d, %r13d
jge 0x2edd
movss (%r14,%r13,4), %xmm1
mulss %xmm2, %xmm1
addss %xmm1, %xmm0
incq %r13
cmpq %r13, %rax
jne 0x2ec4
movl %r13d, %ebp
movss %xmm0, (%rbx)
cmpl $0x2, %r15d
jl 0x2f20
movslq %ebp, %rdx
movl %r15d, %ecx
leaq (%r14,%rdx,4), %rdx
shlq $0x2, %rax
movq %rdx, %rsi
subq %rax, %rsi
decq %rcx
xorl %eax, %eax
movss (%rdx,%rax,4), %xmm1
subss (%rsi,%rax,4), %xmm1
mulss %xmm2, %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0x4(%rbx,%rax,4)
incq %rax
cmpq %rax, %rcx
jne 0x2f00
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x2, %esi
jl 0x2f5f
movl %esi, %eax
incq %rax
movss -0x8(%rdi,%rax,4), %xmm1
subss -0xc(%rdi,%rax,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, -0x8(%rdi,%rax,4)
decq %rax
cmpq $0x2, %rax
jg 0x2f40
movl $0x0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x2, %esi
jl 0x2fb7
movl %esi, %eax
addq $-0x2, %rax
xorl %ecx, %ecx
movss (%rdi,%rcx,4), %xmm0
movss 0x4(%rdi,%rax,4), %xmm1
movss %xmm1, (%rdi,%rcx,4)
movss %xmm0, 0x4(%rdi,%rax,4)
incq %rcx
leaq -0x1(%rax), %rdx
cmpq %rax, %rcx
movq %rdx, %rax
jl 0x2f92
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movss %xmm0, (%rsp)
movl %edi, %ebx
movslq %edi, %rdi
shlq $0x2, %rdi
callq 0x1160
testq %rax, %rax
je 0x30a1
movq %rax, %r14
testl %ebx, %ebx
jle 0x2ff7
movl %ebx, %eax
xorl %ecx, %ecx
movl $0x3f800000, (%r14,%rcx,4) # imm = 0x3F800000
incq %rcx
cmpq %rcx, %rax
jne 0x2fe7
movss 0x39e9(%rip), %xmm1     # 0x69e8
minss (%rsp), %xmm1
xorps %xmm0, %xmm0
cvtsi2ss %ebx, %xmm0
mulss %xmm1, %xmm0
callq 0x1170
cvttss2si %xmm0, %eax
cmpl $0x2, %eax
movl $0x1, %r15d
cmovgel %eax, %r15d
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
movsd 0x39bb(%rip), %xmm1     # 0x69f0
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
decl %ebx
xorps %xmm0, %xmm0
xorl %r12d, %r12d
movss %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtss2sd (%rsp), %xmm0
callq 0x10e0
movsd 0x3010(%rip), %xmm1     # 0x6078
subsd %xmm0, %xmm1
mulsd 0x398c(%rip), %xmm1     # 0x6a00
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movslq %ebx, %rbx
movss %xmm0, (%r14,%rbx,4)
movss %xmm0, (%r14,%r12,4)
movss (%rsp), %xmm0
incq %r12
addss 0x4(%rsp), %xmm0
decl %ebx
cmpq %r12, %r15
jne 0x304e
jmp 0x30a4
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/YunyiQian[P]multitel3/fft.c
// Function: filter
void	filter(complex *d, int n, float f1, float f2, float dt, int sgn) {
     int i, if1, if2;
     float a;
     dt = 0.5/dt/n;
     if1 = rint(f1/dt);
     if2 = rint(f2/dt); if (if2>=n) if2=n-1;
     if (if2<=if1) {
	fprintf(stderr, "filter freq. wrong f2<f1\n");
	return;
     }
     dt = PI/(if2-if1);
     for(a=0.,i=if1;i<if2;i++,a+=dt) d[i] = dmltp(0.5*(1-sgn*cos(a)), d[i]);
     if (sgn<0) {
	for(i=if2;i<n;i++) d[i] = Zero;
	d[0].y = 0.;
     } else  {
        d[0].x = 0.;
        for(i=1;i<if1;i++) d[i] = Zero;
     }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movss %xmm1, 0x4(%rsp)
movl %esi, %r14d
movq %rdi, %rbx
xorps %xmm1, %xmm1
cvtss2sd %xmm2, %xmm1
movsd 0x3922(%rip), %xmm2     # 0x6a00
divsd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtsd2ss %xmm2, %xmm1
movss %xmm1, (%rsp)
divss %xmm1, %xmm0
callq 0x1170
cvttss2si %xmm0, %r15d
movss 0x4(%rsp), %xmm0
divss (%rsp), %xmm0
callq 0x1170
cvttss2si %xmm0, %eax
leal -0x1(%r14), %r12d
cmpl %r14d, %eax
cmovll %eax, %r12d
movl %r12d, %r13d
subl %r15d, %r13d
jle 0x323f
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
movsd 0x38ae(%rip), %xmm1     # 0x69f0
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, (%rsp)
movl %ebp, 0xc(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
xorpd 0x386b(%rip), %xmm0     # 0x69d0
movapd %xmm0, 0x10(%rsp)
movl %r15d, 0x8(%rsp)
movslq %r15d, %rax
leaq (%rbx,%rax,8), %rbp
xorps %xmm1, %xmm1
xorl %r15d, %r15d
movss %xmm1, 0x4(%rsp)
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
callq 0x10e0
mulsd 0x10(%rsp), %xmm0
addsd 0x2edb(%rip), %xmm0     # 0x6078
mulsd 0x385b(%rip), %xmm0     # 0x6a00
cvtsd2ss %xmm0, %xmm0
movsd (%rbp,%r15,8), %xmm1
callq 0x384c
movss 0x4(%rsp), %xmm1
movlps %xmm0, (%rbp,%r15,8)
addss (%rsp), %xmm1
incq %r15
cmpl %r15d, %r13d
jne 0x317d
cmpl $0x0, 0xc(%rsp)
js 0x3209
movl $0x0, (%rbx)
movl 0x8(%rsp), %eax
cmpl $0x2, %eax
jl 0x3230
movl %eax, %r14d
movl $0x1, %r15d
xorpd %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x3954
movlpd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x31ed
jmp 0x3230
movslq %r12d, %r15
movslq %r14d, %r14
xorpd %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x3954
movlpd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq %r14, %r15
jl 0x320f
movl $0x0, 0x4(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1299
jmp 0x3230
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x0, (%rdx)
testl %esi, %esi
jle 0x3276
movss (%rdx), %xmm0
movl %esi, %ecx
xorl %esi, %esi
xorl %eax, %eax
movss (%rdi,%rsi,4), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x326d
movss %xmm1, (%rdx)
movaps %xmm1, %xmm0
movl %esi, %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x325a
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x0, (%rdx)
testl %esi, %esi
jle 0x32bc
movss (%rdx), %xmm0
movl %esi, %ecx
xorl %esi, %esi
movaps 0x2d8e(%rip), %xmm1     # 0x6020
xorl %eax, %eax
movss (%rdi,%rsi,4), %xmm2
movaps %xmm2, %xmm3
andps %xmm1, %xmm3
movaps %xmm0, %xmm4
andps %xmm1, %xmm4
ucomiss %xmm4, %xmm3
jbe 0x32b3
movss %xmm2, (%rdx)
movaps %xmm2, %xmm0
movl %esi, %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x3294
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl %esi, %eax
testl %esi, %esi
jle 0x32fc
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
cvtsi2ss %ecx, %xmm2
movss (%rdi,%rcx,4), %xmm3
mulss %xmm3, %xmm2
cvtss2sd %xmm2, %xmm2
addsd %xmm2, %xmm1
xorps %xmm2, %xmm2
cvtss2sd %xmm3, %xmm2
addsd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x32cf
jmp 0x3304
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testl %esi, %esi
jle 0x33ba
xorps %xmm2, %xmm2
cvtsi2sd %esi, %xmm2
movsd 0x36e5(%rip), %xmm3     # 0x6a00
mulsd %xmm2, %xmm3
leal -0x1(%rsi), %ecx
cvtsi2sd %ecx, %xmm4
mulsd %xmm3, %xmm4
leal -0x1(%rsi,%rsi), %ecx
xorps %xmm3, %xmm3
cvtsi2sd %ecx, %xmm3
mulsd %xmm4, %xmm3
divsd 0x36c7(%rip), %xmm3     # 0x6a08
movapd 0x3687(%rip), %xmm5     # 0x69d0
xorpd %xmm4, %xmm5
movapd %xmm1, %xmm6
mulsd %xmm4, %xmm6
mulsd %xmm4, %xmm4
movapd %xmm3, %xmm7
mulsd %xmm2, %xmm7
subsd %xmm4, %xmm7
mulsd %xmm0, %xmm3
subsd %xmm6, %xmm3
divsd %xmm7, %xmm3
mulsd %xmm0, %xmm5
mulsd %xmm1, %xmm2
addsd %xmm5, %xmm2
xorpd 0x364b(%rip), %xmm2     # 0x69d0
divsd %xmm7, %xmm2
xorl %ecx, %ecx
xorps %xmm0, %xmm0
cvtss2sd (%rdi,%rcx,4), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
subsd %xmm3, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, (%rdi,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x338b
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cvtsi2sd %esi, %xmm1
movsd 0x361d(%rip), %xmm2     # 0x69f0
divsd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtsd2ss %xmm2, %xmm1
movss %xmm1, (%rsp)
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
cmpl $0x2, %esi
jl 0x346b
movl %esi, %r14d
movl $0x1, %r15d
movss (%rsp), %xmm0
movsd %xmm1, 0x8(%rsp)
movss %xmm0, 0x4(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rsp), %xmm0
mulsd 0x35e6(%rip), %xmm0     # 0x6a00
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, %xmm1
xorps 0x2be4(%rip), %xmm1     # 0x6010
mulss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
callq 0x1230
cvtsd2ss %xmm0, %xmm0
movsd (%rbx,%r15,8), %xmm1
callq 0x384c
movsd 0x8(%rsp), %xmm1
movlps %xmm0, (%rbx,%r15,8)
movss 0x4(%rsp), %xmm0
incq %r15
addss (%rsp), %xmm0
cmpq %r15, %r14
jne 0x3403
jmp 0x3470
movss (%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0x3584(%rip), %xmm0     # 0x6a00
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movaps 0x2b85(%rip), %xmm1     # 0x6010
xorps %xmm0, %xmm1
mulss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
callq 0x1230
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rbx), %xmm1
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x4(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movss %xmm0, 0x4(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
movl $0x2, %eax
movl %eax, %r14d
leal (%r14,%r14), %eax
cmpl %ebp, %r14d
jl 0x34db
shrl %r14d
leaq (,%r14,8), %rdi
callq 0x1160
movq %rax, %r15
cmpl $0x1, %r14d
movl %r14d, %r12d
adcl $0x0, %r12d
xorl %r13d, %r13d
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x3954
movlps %xmm0, (%r15,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x3508
movslq %ebp, %r12
shlq $0x2, %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1130
movss 0x34a3(%rip), %xmm0     # 0x69e0
movq %r15, %rdi
movl %r14d, %esi
callq 0x243e
movq %r15, %rdi
movl %r14d, %esi
movss 0x4(%rsp), %xmm0
callq 0x33bb
movss 0x3483(%rip), %xmm0     # 0x69e4
movq %r15, %rdi
movl %r14d, %esi
callq 0x243e
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1130
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movaps %xmm0, %xmm2
movq %rdi, %rbx
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
movsd 0x343f(%rip), %xmm1     # 0x69f0
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
cmpl $0x2, %esi
jl 0x3659
movl %esi, %r14d
movl $0x1, %r15d
movss 0x8(%rsp), %xmm0
movss %xmm2, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
mulss %xmm2, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
callq 0x10e0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x11e0
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
xorps 0x29ee(%rip), %xmm1     # 0x6010
movss 0x14(%rsp), %xmm0
callq 0x3954
movsd (%rbx,%r15,8), %xmm1
callq 0x37dc
movss 0x10(%rsp), %xmm2
movlps %xmm0, (%rbx,%r15,8)
movss 0xc(%rsp), %xmm0
incq %r15
addss 0x8(%rsp), %xmm0
cmpq %r15, %r14
jne 0x35e0
jmp 0x365f
movss 0x8(%rsp), %xmm0
mulss %xmm2, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x10e0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rbx), %xmm1
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x4(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
testl %esi, %esi
jle 0x36d5
movq %rdi, %r14
movl %ebx, %r15d
xorps %xmm1, %xmm1
xorl %r12d, %r12d
movss %xmm1, 0x4(%rsp)
movsd (%r14,%r12,8), %xmm0
callq 0x392c
movss 0x4(%rsp), %xmm1
cvtsd2ss %xmm0, %xmm0
mulss %xmm0, %xmm0
addss %xmm0, %xmm1
incq %r12
cmpq %r12, %r15
jne 0x36a8
jmp 0x36d8
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
cvtsi2ss %ebx, %xmm0
divss %xmm0, %xmm1
movaps %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3     # xmm3 = xmm3[1,1],xmm1[1,1]
movaps %xmm3, %xmm4
movaps %xmm0, %xmm2
mulss %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
mulss %xmm0, %xmm4
mulss %xmm1, %xmm2
subss %xmm4, %xmm2
mulss %xmm1, %xmm0
addss %xmm0, %xmm3
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
movaps %xmm2, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/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:
subq $0x38, %rsp
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movaps %xmm0, 0x10(%rsp)
mulss %xmm0, %xmm0
movaps %xmm1, 0x20(%rsp)
mulss %xmm1, %xmm1
addss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x38af
sqrtsd %xmm0, %xmm0
jmp 0x38b7
callq 0x1220
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x38c3
sqrtsd %xmm0, %xmm0
jmp 0x38c8
callq 0x1220
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x20(%rsp), %xmm1
callq 0x1190
mulsd 0x3113(%rip), %xmm0     # 0x6a00
movsd %xmm0, 0x10(%rsp)
callq 0x10e0
mulsd 0x8(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x11e0
mulsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
movaps 0x20(%rsp), %xmm0
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x3092(%rip), %rsi      # 0x6a60
callq 0x11c0
testq %rax, %rax
je 0x3a06
movq %rax, %r14
movl $0x278, %esi            # imm = 0x278
movl $0x1, %edx
movq %r15, %rdi
movq %rax, %rcx
callq 0x1070
cmpq $0x1, %rax
jne 0x3a23
movq %r14, %rdi
callq 0x1090
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x65eb(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x304c(%rip), %rsi      # 0x6a63
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1120
jmp 0x3a46
movq 0x65ce(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x3042(%rip), %rsi      # 0x6a76
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1120
movq %r14, %rdi
callq 0x1090
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3a00
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2ffe(%rip), %rsi      # 0x6a60
callq 0x11c0
testq %rax, %rax
je 0x3ac8
movq %rax, %r15
movl $0x278, %esi            # imm = 0x278
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0x1070
cmpq $0x1, %rax
jne 0x3adb
movl 0x13c(%r14), %r12d
shll $0x2, %r12d
movq %r12, %rdi
callq 0x1160
testq %rax, %rax
je 0x3aee
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x1070
cmpq $0x1, %rax
jne 0x3b01
movq %r15, %rdi
callq 0x1090
jmp 0x3b1f
movq 0x6529(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2f8a(%rip), %rsi      # 0x6a63
jmp 0x3b12
movq 0x6516(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2f8a(%rip), %rsi      # 0x6a76
jmp 0x3b12
movq 0x6503(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2f97(%rip), %rsi      # 0x6a96
jmp 0x3b12
movq 0x64f0(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2faf(%rip), %rsi      # 0x6ac1
xorl %r14d, %r14d
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1120
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/YunyiQian[P]multitel3/sacio.c
// Function: write_sac
int	write_sac(const char	*name,
		SACHEAD		hd,
		const float	*ar
	)
{
  FILE		*strm;
  unsigned	sz;
  float		*data;
  int		error = 0;

  sz = hd.npts*sizeof(float);
  if (hd.iftype == IXY) sz *= 2;

  if ((data = (float *) malloc(sz)) == NULL) {
     fprintf(stderr, "Error in allocating memory for writing %s\n",name);
     error = 1;
  }

  if ( !error && memcpy(data, ar, sz) == NULL) {
     fprintf(stderr, "Error in copying data for writing %s\n",name);
     error = 1;
  }

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

  if ( !error && (strm = fopen(name, "w")) == NULL ) {
     fprintf(stderr,"Error in opening file for writing %s\n",name);
     error = 1;
  }

  if ( !error && fwrite(&hd, sizeof(SACHEAD), 1, strm) != 1 ) {
     fprintf(stderr,"Error in writing SAC header for writing %s\n",name);
     error = 1;
  }

  if ( !error && fwrite(data, sz, 1, strm) != 1 ) {
     fprintf(stderr,"Error in writing SAC data for writing %s\n",name);
     error = 1;
  }

  free(data);
  fclose(strm);

  return (error==0) ? 0 : -1;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
movl 0x16c(%rsp), %r15d
cmpl $0x4, 0x184(%rsp)
sete %cl
orb $0x2, %cl
shll %cl, %r15d
movq %r15, %rdi
callq 0x1160
movq %rax, %r14
testq %rax, %rax
je 0x3bec
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1130
leaq 0x2f8c(%rip), %rsi      # 0x6b0a
movq %rbx, %rdi
callq 0x11c0
testq %rax, %rax
je 0x3bf5
movq %rax, %r12
movb $0x1, %al
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %al, %al
je 0x3bd1
leaq 0x30(%rsp), %rdi
movl $0x278, %esi            # imm = 0x278
movl $0x1, %edx
movq %r12, %rcx
callq 0x1210
cmpq $0x1, %rax
jne 0x3c1a
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x1210
xorl %ebp, %ebp
cmpq $0x1, %rax
jne 0x3c23
movq %r14, %rdi
callq 0x1040
movq %r12, %rdi
callq 0x1090
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2eec(%rip), %rsi      # 0x6adf
jmp 0x3bfc
leaq 0x2f10(%rip), %rsi      # 0x6b0c
movq 0x63f5(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
xorl %r12d, %r12d
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1120
xorl %eax, %eax
jmp 0x3b90
leaq 0x2f11(%rip), %rsi      # 0x6b32
jmp 0x3c2a
leaq 0x2f34(%rip), %rsi      # 0x6b5e
movq 0x63c7(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1120
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x3bd1
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movss %xmm1, 0x4(%rsp)
movl %esi, %ebx
movss %xmm0, (%rsp)
movq %rdi, %r14
leaq 0x2f7c(%rip), %rsi      # 0x6c04
movl $0x278, %edx            # imm = 0x278
callq 0x1130
movl %ebx, 0x13c(%r14)
movss (%rsp), %xmm2
movss %xmm2, (%r14)
movss 0x4(%rsp), %xmm1
movss %xmm1, 0x14(%r14)
movl $0x0, 0x1c(%r14)
decl %ebx
xorps %xmm0, %xmm0
cvtsi2ss %ebx, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x18(%r14)
movl $0xb, 0x15c(%r14)
movl $0x1, %eax
movl %eax, 0x154(%r14)
movl %eax, 0x1a4(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4f0, %rsp            # imm = 0x4F0
movq %rcx, %r14
movq %rdx, %r13
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x2eea(%rip), %rsi      # 0x6c04
leaq 0x278(%rsp), %r12
movl $0x278, %edx            # imm = 0x278
movq %r12, %rdi
callq 0x1130
movl %r15d, 0x13c(%r12)
movl $0x4, 0x154(%r12)
movl $0x0, 0x1a4(%r12)
leal (,%r15,8), %edi
callq 0x1160
testq %rax, %rax
je 0x3dc0
movq %rax, %r12
shll $0x2, %r15d
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x1130
leaq (%r12,%r15,4), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1130
leaq 0x278(%rsp), %rsi
movl $0x4f, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3b2e
movl %eax, %ebx
movq %r12, %rdi
callq 0x1040
movl %ebx, %eax
addq $0x4f0, %rsp            # imm = 0x4F0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x6231(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2db7(%rip), %rsi      # 0x6b88
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1120
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3daf
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rsp, %rbp
movq %rbp, %rsi
callq 0x3a4d
movq %rax, %r14
movss (%rbp), %xmm0
movss %xmm0, (%r13)
movslq 0x13c(%rbp), %rdx
movl %edx, (%r12)
movss 0x14(%rbp), %xmm0
movss %xmm0, (%r15)
testq %rdx, %rdx
jle 0x3e41
shlq $0x2, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1130
movq %r14, %rdi
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x500, %rsp            # imm = 0x500
movq %r9, %rbx
movq %r8, %r15
movq %rdi, %r14
movss (%rsi), %xmm0
movss %xmm0, 0x280(%rsp)
movl (%rdx), %r13d
movss (%rcx), %xmm0
movss %xmm0, 0x284(%rsp)
leaq 0x2a8(%rsp), %r12
leaq 0x2d85(%rip), %rsi      # 0x6c24
movl $0x11c, %edx            # imm = 0x11C
movq %r12, %rdi
callq 0x1130
leaq 0x2d51(%rip), %rax      # 0x6c04
movups 0x2e8a(%rip), %xmm0     # 0x6d44
movups %xmm0, 0x120(%r12)
movl $0xffffcfc7, 0x130(%r12) # imm = 0xFFFFCFC7
movl $0x160, %esi            # imm = 0x160
leaq 0x288(%rsp), %r12
leaq (%r12,%rsi), %rdi
addq %rax, %rsi
movl $0x11, %ecx
rep  movsl (%rsi), %es:(%rdi)
movl $0x1a8, %ecx            # imm = 0x1A8
leaq (%r12,%rcx), %rdi
addq %rcx, %rax
movl $0xd0, %edx
movq %rax, %rsi
callq 0x1130
leal -0x1(%r13), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x280(%rsp), %xmm1
mulss %xmm1, %xmm0
movss 0x284(%rsp), %xmm2
addss %xmm2, %xmm0
movss %xmm1, (%r12)
movups 0x2cd3(%rip), %xmm1     # 0x6c08
movups %xmm1, 0x4(%r12)
movss %xmm2, 0x14(%r12)
movss %xmm0, 0x18(%r12)
movl $0x0, 0x1c(%r12)
movl %r13d, 0x13c(%r12)
movabsq $-0x3038ffffffff, %rax  # imm = 0xFFFFCFC700000001
movq %rax, 0x154(%r12)
movl $0xb, 0x15c(%r12)
movl $0x1, 0x1a4(%r12)
movss (%r15), %xmm0
movss %xmm0, 0xc8(%r12)
movl $0x4f, %ecx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b2e
addq $0x500, %rsp            # imm = 0x500
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4f8, %rsp            # imm = 0x4F8
movq %r9, %r15
movq %r8, %r12
movq %rdi, %rbx
movq 0x530(%rsp), %rbp
movss (%rsi), %xmm0
movss %xmm0, 0x278(%rsp)
movl (%rdx), %r14d
movss (%rcx), %xmm0
movss %xmm0, 0x27c(%rsp)
leaq 0x2a0(%rsp), %r13
leaq 0x2c19(%rip), %rsi      # 0x6c24
movl $0x11c, %edx            # imm = 0x11C
movq %r13, %rdi
callq 0x1130
leaq 0x2be5(%rip), %rax      # 0x6c04
movups 0x2d1e(%rip), %xmm0     # 0x6d44
movups %xmm0, 0x120(%r13)
movl $0xffffcfc7, 0x130(%r13) # imm = 0xFFFFCFC7
movl $0x160, %esi            # imm = 0x160
leaq 0x280(%rsp), %r13
leaq (%rsi,%r13), %rdi
addq %rax, %rsi
movl $0x11, %ecx
rep  movsl (%rsi), %es:(%rdi)
movl $0x1a8, %ecx            # imm = 0x1A8
leaq (%rcx,%r13), %rdi
addq %rcx, %rax
movl $0xd0, %edx
movq %rax, %rsi
callq 0x1130
leal -0x1(%r14), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x278(%rsp), %xmm1
mulss %xmm1, %xmm0
movss 0x27c(%rsp), %xmm2
addss %xmm2, %xmm0
movss %xmm1, (%r13)
movups 0x2b69(%rip), %xmm1     # 0x6c08
movups %xmm1, 0x4(%r13)
movss %xmm2, 0x14(%r13)
movss %xmm0, 0x18(%r13)
xorl %eax, %eax
movl %eax, 0x1c(%r13)
movl %r14d, 0x13c(%r13)
movabsq $-0x3038ffffffff, %rcx  # imm = 0xFFFFCFC700000001
movq %rcx, 0x154(%r13)
movl $0xb, 0x15c(%r13)
movl $0x1, 0x1a4(%r13)
movss (%rbp), %xmm0
movss %xmm0, 0xd4(%r13)
movq 0x538(%rsp), %rcx
movss (%rcx), %xmm0
movss %xmm0, 0xcc(%r13)
movss 0x2935(%rip), %xmm0     # 0x6a44
addss %xmm0, %xmm2
movss %xmm2, 0x34(%r13)
movss (%r12), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x2c(%r13)
addss (%r15), %xmm0
movss %xmm0, 0x30(%r13)
movl %eax, 0x1c(%r13)
movq 0x540(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0xa4(%r13)
movl $0x4f, %ecx
movq %rsp, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq 0x548(%rsp), %rsi
callq 0x3b2e
addq $0x4f8, %rsp            # imm = 0x4F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x508, %rsp            # imm = 0x508
movq %rdx, %rbx
movss %xmm4, 0x28c(%rsp)
movss %xmm3, 0x288(%rsp)
movss %xmm2, 0x284(%rsp)
movss %xmm1, 0x280(%rsp)
movl %esi, %r15d
movss %xmm0, 0x27c(%rsp)
movq %rdi, %r14
leaq 0x2b0(%rsp), %r12
leaq 0x2a4f(%rip), %rsi      # 0x6c24
movl $0x11c, %edx            # imm = 0x11C
movq %r12, %rdi
callq 0x1130
leaq 0x2a1b(%rip), %rax      # 0x6c04
movups 0x2b54(%rip), %xmm0     # 0x6d44
movups %xmm0, 0x120(%r12)
movl $0xffffcfc7, 0x130(%r12) # imm = 0xFFFFCFC7
movl $0x160, %esi            # imm = 0x160
leaq 0x290(%rsp), %r12
leaq (%r12,%rsi), %rdi
addq %rax, %rsi
movl $0x11, %ecx
rep  movsl (%rsi), %es:(%rdi)
movl $0x1a8, %ecx            # imm = 0x1A8
leaq (%r12,%rcx), %rdi
addq %rcx, %rax
movl $0xd0, %edx
movq %rax, %rsi
callq 0x1130
leal -0x1(%r15), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x27c(%rsp), %xmm1
mulss %xmm1, %xmm0
movss 0x280(%rsp), %xmm2
addss %xmm2, %xmm0
movss %xmm1, (%r12)
movups 0x299d(%rip), %xmm1     # 0x6c08
movups %xmm1, 0x4(%r12)
movss %xmm2, 0x14(%r12)
movss %xmm0, 0x18(%r12)
movl $0x0, 0x1c(%r12)
movl %r15d, 0x13c(%r12)
movabsq $-0x3038ffffffff, %rax  # imm = 0xFFFFCFC700000001
movq %rax, 0x154(%r12)
movl $0xb, 0x15c(%r12)
movl $0x1, 0x1a4(%r12)
movss 0x284(%rsp), %xmm0
movss %xmm0, 0xc8(%r12)
movss 0x288(%rsp), %xmm0
movss %xmm0, 0xe4(%r12)
movss 0x28c(%rsp), %xmm0
movss %xmm0, 0xe8(%r12)
movl $0x4f, %ecx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b2e
addq $0x508, %rsp            # imm = 0x508
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cvtss2sd %xmm0, %xmm0
movsd 0x26ab(%rip), %xmm2     # 0x6e80
mulsd %xmm2, %xmm0
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm1, %xmm1
mulsd %xmm2, %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, 0x10(%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rsp)
callq 0x11e0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movsd (%rsp), %xmm0
callq 0x10e0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x10(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
callq 0x11e0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x10e0
cvtsd2ss %xmm0, %xmm0
movaps 0x10(%rsp), %xmm1
xorps 0x17be(%rip), %xmm1     # 0x6010
movss %xmm1, (%rbx)
movss %xmm1, 0x4(%rbx)
movl $0x0, 0x8(%rbx)
movss (%rsp), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0xc(%rbx)
movss %xmm1, 0x10(%rbx)
movss 0xc(%rsp), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0x14(%rbx)
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/YunyiQian[P]multitel3/radiats.c
// Function: mt_radiat
void	mt_radiat(float az, float m[3][3], float rad[4][3]) {
   float saz, caz, saz2, caz2;
   az *= DEG2RAD;
   saz = sin(az); caz = cos(az);
   saz2 = 2*saz*caz; caz2 = caz*caz-saz*saz;
   rad[2][0] = rad[2][1] = -0.5*(m[0][0]-m[1][1])*caz2 - m[0][1]*saz2; 
   rad[1][0] = rad[1][1] = -m[0][2]*caz - m[1][2]*saz;
   rad[0][0] = rad[0][1] =  (2*m[2][2]-m[0][0]-m[1][1])/6.;
   rad[2][2] = -0.5*(m[0][0]-m[1][1])*saz2 + m[0][1]*caz2;
   rad[1][2] = -m[0][2]*saz + m[1][2]*caz;
   rad[0][2] = 0.;
   /* contribution from explosion: */
   rad[3][0] = rad[3][1] = (m[0][0]+m[1][1]+m[2][2])/3.;
   rad[3][2] = 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
cvtss2sd %xmm0, %xmm0
mulsd 0x25e0(%rip), %xmm0     # 0x6e80
movq %rdi, %r14
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x11e0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x10e0
cvtsd2ss %xmm0, %xmm0
movss 0xc(%rsp), %xmm2
movaps %xmm2, %xmm1
addss %xmm2, %xmm1
mulss %xmm0, %xmm1
movaps %xmm2, %xmm3
movaps %xmm2, %xmm6
mulss %xmm2, %xmm3
movaps %xmm0, %xmm2
mulss %xmm0, %xmm2
subss %xmm3, %xmm2
movss (%r14), %xmm3
subss 0x10(%r14), %xmm3
cvtss2sd %xmm3, %xmm4
movsd 0x257c(%rip), %xmm3     # 0x6e88
mulsd %xmm3, %xmm4
cvtss2sd %xmm2, %xmm5
mulsd %xmm4, %xmm5
movss 0x4(%r14), %xmm4
mulss %xmm1, %xmm4
cvtss2sd %xmm4, %xmm4
subsd %xmm4, %xmm5
xorps %xmm4, %xmm4
cvtsd2ss %xmm5, %xmm4
movss %xmm4, 0x1c(%rbx)
movss %xmm4, 0x18(%rbx)
movss 0x8(%r14), %xmm4
xorps 0x16c8(%rip), %xmm4     # 0x6010
movss 0x14(%r14), %xmm5
mulss %xmm6, %xmm5
mulss %xmm0, %xmm4
subss %xmm5, %xmm4
movss %xmm4, 0x10(%rbx)
movss %xmm4, 0xc(%rbx)
movss 0x20(%r14), %xmm4
addss %xmm4, %xmm4
subss (%r14), %xmm4
subss 0x10(%r14), %xmm4
divss 0x252f(%rip), %xmm4     # 0x6eb0
movss %xmm4, 0x4(%rbx)
movss %xmm4, (%rbx)
movss (%r14), %xmm4
subss 0x10(%r14), %xmm4
cvtss2sd %xmm4, %xmm4
mulsd %xmm3, %xmm4
cvtss2sd %xmm1, %xmm1
mulsd %xmm4, %xmm1
mulss 0x4(%r14), %xmm2
cvtss2sd %xmm2, %xmm2
addsd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtsd2ss %xmm2, %xmm1
movss %xmm1, 0x20(%rbx)
mulss 0x14(%r14), %xmm0
mulss 0x8(%r14), %xmm6
subss %xmm6, %xmm0
movss %xmm0, 0x14(%rbx)
xorl %eax, %eax
movl %eax, 0x8(%rbx)
movss (%r14), %xmm0
addss 0x10(%r14), %xmm0
addss 0x20(%r14), %xmm0
divss 0x24c2(%rip), %xmm0     # 0x6eb4
movss %xmm0, 0x28(%rbx)
movss %xmm0, 0x24(%rbx)
movl %eax, 0x2c(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/YunyiQian[P]multitel3/radiats.c
// Function: radpmt
float radpmt(float mom[3][3], float alpha, float az, int type) {
  float	dir[3], wave[3], sth, cth, cphi, sphi;
  int	m,n;
  
  sth=sin(alpha*DEG2RAD);
  cth=cos(alpha*DEG2RAD);
  cphi=cos(az*DEG2RAD);
  sphi=sin(az*DEG2RAD);
  dir[0]=sth*cphi;
  dir[1]=sth*sphi;
  dir[2]=cth;
  switch(type) {
  case 1:	/* P wave */
    wave[0]=dir[0];
    wave[1]=dir[1];
    wave[2]=dir[2];
    break;
  case 2:	/* SV wave */
    wave[0]=cth*cphi;
    wave[1]=cth*sphi;
    wave[2]=-sth;
    break;
  case 3:	/* SH wave */
    wave[0]=-sphi;
    wave[1]=cphi;
    wave[2]=0;
  break;
  default:
    fprintf(stderr,"wrong phase type %d\n",type);
    return 0.;
  }
  
  sth=0;
  for(m=0;m<3;m++){
    for(n=0;n<3;n++){
      sth+=mom[m][n]*dir[m]*wave[n];
    }
  }
  return sth;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movss %xmm1, 0x18(%rsp)
movq %rdi, %rbx
cvtss2sd %xmm0, %xmm0
mulsd 0x1ec2(%rip), %xmm0     # 0x6e80
movsd %xmm0, 0x10(%rsp)
callq 0x11e0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x10e0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x18(%rsp), %xmm0
mulsd 0x1e88(%rip), %xmm0     # 0x6e80
movsd %xmm0, 0x18(%rsp)
callq 0x10e0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x11e0
movss 0x20(%rsp), %xmm5
movaps 0x30(%rsp), %xmm4
movss 0x10(%rsp), %xmm3
cvtsd2ss %xmm0, %xmm0
movaps %xmm4, %xmm1
mulss %xmm5, %xmm1
movss %xmm1, 0x24(%rsp)
movaps %xmm4, %xmm2
mulss %xmm0, %xmm2
movss %xmm2, 0x28(%rsp)
movss %xmm3, 0x2c(%rsp)
cmpl $0x3, %ebp
je 0x506e
cmpl $0x2, %ebp
je 0x5086
cmpl $0x1, %ebp
jne 0x50e7
movss %xmm1, 0x4(%rsp)
movss %xmm2, 0x8(%rsp)
jmp 0x50a4
xorps 0xf9b(%rip), %xmm0      # 0x6010
movss %xmm0, 0x4(%rsp)
movss %xmm5, 0x8(%rsp)
xorps %xmm3, %xmm3
jmp 0x50a4
mulss %xmm3, %xmm5
movss %xmm5, 0x4(%rsp)
mulss %xmm3, %xmm0
movss %xmm0, 0x8(%rsp)
xorps 0xf6f(%rip), %xmm4      # 0x6010
movaps %xmm4, %xmm3
movss %xmm3, 0xc(%rsp)
xorps %xmm0, %xmm0
xorl %eax, %eax
movss 0x24(%rsp,%rax,4), %xmm1
xorl %ecx, %ecx
movss (%rbx,%rcx,4), %xmm2
mulss %xmm1, %xmm2
mulss 0x4(%rsp,%rcx,4), %xmm2
addss %xmm2, %xmm0
incq %rcx
cmpq $0x3, %rcx
jne 0x50b7
incq %rax
addq $0xc, %rbx
cmpq $0x3, %rax
jne 0x50af
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq 0x4f0a(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x1dc4(%rip), %rsi      # 0x6ebc
movl %ebp, %edx
xorl %eax, %eax
callq 0x1120
xorps %xmm0, %xmm0
jmp 0x50e0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xe4d(%rip), %rsi       # 0x60f1
callq 0x1190
testq %rax, %rax
je 0x52b5
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x12cd