LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x2abc
minss %xmm1, %xmm2
ucomiss %xmm2, %xmm3
ja 0x2abc
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movabsq $0x100000000, %r15      # imm = 0x100000000
movaps %xmm3, %xmm0
movss %xmm2, 0xc(%rsp)
movss %xmm3, 0x8(%rsp)
callq 0x11c0
cvttss2si %xmm0, %eax
leal 0x1(%rax), %ecx
cvtsi2ss %ecx, %xmm0
subss 0x8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
movslq %eax, %r14
mulss (%rbx,%r14,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x3ff1(%rip), %xmm2     # 0x69f8
subsd %xmm1, %xmm2
cvtss2sd 0x4(%rbx,%r14,4), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm0, %xmm3
mulsd %xmm1, %xmm3
cvtsd2ss %xmm3, %xmm0
movss %xmm0, 0x8(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x10f0
movss 0x8(%rsp), %xmm4
cvttss2si %xmm0, %ecx
leaq 0x1(%r14), %rax
movslq %ecx, %rcx
shlq $0x20, %r14
addq %r15, %r14
cmpq %rcx, %rax
jge 0x2a64
movss (%rbx,%rax,4), %xmm0
addss 0x4(%rbx,%rax,4), %xmm0
incq %rax
addss %xmm0, %xmm4
jmp 0x2a48
cvtsi2ss %eax, %xmm0
subss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
sarq $0x1e, %r14
mulss -0x4(%rbx,%r14), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x3f6f(%rip), %xmm3     # 0x69f8
subsd %xmm1, %xmm3
cvtss2sd (%rbx,%r14), %xmm2
mulsd %xmm3, %xmm2
addsd %xmm0, %xmm2
cvtss2sd %xmm4, %xmm0
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm0
cvtsd2ss %xmm0, %xmm0
mulss 0x3f35(%rip), %xmm0     # 0x69e8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
cvtsi2ss %edx, %xmm1
movss %xmm1, 0xc(%rsp)
subss %xmm1, %xmm0
callq 0x11c0
movss %xmm0, 0x8(%rsp)
movss (%rsp), %xmm0
subss 0xc(%rsp), %xmm0
callq 0x11c0
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
testl %ebx, %ebx
jle 0x2bab
cvttss2si 0x8(%rsp), %eax
cvttss2si %xmm1, %ecx
addl %ebx, %ebx
cmpl %eax, %ecx
setge %dl
testl %eax, %eax
setns %sil
andb %dl, %sil
leal (%rbx,%rcx), %edx
cmpl %ebp, %edx
setl %dl
andb %sil, %dl
cmpb $0x1, %dl
jne 0x2bab
movslq %ecx, %rdx
movl %eax, %ecx
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
leaq (%r14,%rcx,4), %rcx
leaq (%r14,%rdx,4), %rdx
xorps %xmm1, %xmm1
cmpq %rax, %rbx
je 0x2b75
movss (%rdx,%rax,4), %xmm2
movaps %xmm2, %xmm3
mulss %xmm2, %xmm3
addss %xmm3, %xmm0
movss (%rcx,%rax,4), %xmm3
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
shufps $0x0, %xmm3, %xmm3      # xmm3 = xmm3[0,0,0,0]
mulps %xmm2, %xmm3
addps %xmm3, %xmm1
incq %rax
jmp 0x2b49
cvtss2sd %xmm1, %xmm2
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2b94
sqrtsd %xmm0, %xmm0
jmp 0x2ba3
movsd %xmm2, (%rsp)
callq 0x1210
movsd (%rsp), %xmm2
divsd %xmm0, %xmm2
cvtsd2ss %xmm2, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
xorps %xmm1, %xmm1
cmpq %rax, %rsi
je 0x2bda
movss (%rdi,%rax,4), %xmm2
mulss %xmm0, %xmm2
addss %xmm2, %xmm1
movss %xmm1, (%rdi,%rax,4)
incq %rax
jmp 0x2bbe
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2
popq %rcx
cltd
cvtsi2sd %r12d, %xmm0
movsd 0x3433(%rip), %xmm1     # 0x6038
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
idivl %ecx
movl %eax, %ebp
leal (%r12,%r15), %eax
decl %eax
movslq %eax, %rdi
pushq $0x4
popq %rsi
callq 0x1100
movq %rax, %r14
movslq %ebp, %rbp
movslq %r15d, %r13
leaq (,%r13,4), %rdx
leaq (%rax,%rbp,4), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1120
movss 0x4(%rsp), %xmm2
movslq %r12d, %rax
xorps %xmm0, %xmm0
cmpq %rax, %rbp
jge 0x2c6f
movss (%r15), %xmm1
mulss %xmm2, %xmm1
addss %xmm1, %xmm0
incq %rbp
addq $0x4, %r15
jmp 0x2c54
movss %xmm0, (%rbx)
shlq $0x2, %rax
negq %rax
pushq $0x1
popq %rcx
cmpq %r13, %rcx
jge 0x2ca3
movss (%r15), %xmm1
subss (%r15,%rax), %xmm1
mulss %xmm2, %xmm1
addss %xmm1, %xmm0
movss %xmm0, (%rbx,%rcx,4)
incq %rcx
addq $0x4, %r15
jmp 0x2c7d
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_O2/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:
movl %esi, %eax
cmpl $0x2, %eax
jl 0x2cdb
movss -0x4(%rdi,%rax,4), %xmm1
subss -0x8(%rdi,%rax,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, -0x4(%rdi,%rax,4)
decq %rax
jmp 0x2cbb
andl $0x0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movslq %esi, %rax
decq %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0x2d28
movss (%rdi,%rcx,4), %xmm0
movss (%rdi,%rax,4), %xmm1
movss %xmm1, (%rdi,%rcx,4)
movss %xmm0, (%rdi,%rax,4)
incq %rcx
decq %rax
jmp 0x2d07
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1150
movq %rax, %r14
testq %rax, %rax
je 0x2e07
xorl %eax, %eax
testl %ebx, %ebx
movl $0x0, %ecx
cmovgl %ebx, %ecx
cmpq %rax, %rcx
je 0x2d6e
movl $0x3f800000, (%r14,%rax,4) # imm = 0x3F800000
incq %rax
jmp 0x2d5c
movss 0x3c72(%rip), %xmm1     # 0x69e8
minss (%rsp), %xmm1
cvtsi2ss %ebx, %xmm0
mulss %xmm1, %xmm0
callq 0x1160
cvttss2si %xmm0, %eax
cmpl $0x2, %eax
pushq $0x1
popq %r15
cmovgel %eax, %r15d
cvtsi2sd %r15d, %xmm0
movsd 0x3c4c(%rip), %xmm1     # 0x69f0
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
decl %ebx
xorps %xmm0, %xmm0
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x2e07
movss %xmm0, (%rsp)
cvtss2sd (%rsp), %xmm0
callq 0x10d0
movsd 0x3262(%rip), %xmm1     # 0x6038
subsd %xmm0, %xmm1
mulsd 0x3c1e(%rip), %xmm1     # 0x6a00
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
jmp 0x2dba
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x8(%rsp)
movl %esi, %r14d
movq %rdi, %rbx
cvtss2sd %xmm2, %xmm1
movsd 0x3bc2(%rip), %xmm2     # 0x6a00
divsd %xmm1, %xmm2
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm2
cvtsd2ss %xmm2, %xmm1
movss %xmm1, 0xc(%rsp)
divss %xmm1, %xmm0
callq 0x1160
cvttss2si %xmm0, %r15d
movss 0x8(%rsp), %xmm0
divss 0xc(%rsp), %xmm0
callq 0x1160
cvttss2si %xmm0, %ecx
leal -0x1(%r14), %eax
cmpl %r14d, %ecx
cmovll %ecx, %eax
movl %eax, %ecx
subl %r15d, %ecx
jle 0x2f6f
cvtsi2sd %ecx, %xmm0
movsd 0x3b58(%rip), %xmm1     # 0x69f0
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
cvtsi2sd %ebp, %xmm0
xorpd 0x3b1e(%rip), %xmm0     # 0x69d0
movapd %xmm0, 0x10(%rsp)
movslq %r15d, %r15
movslq %eax, %r12
xorpd %xmm0, %xmm0
movq %r15, %r13
cmpq %r12, %r13
jge 0x2f16
movss %xmm0, 0x8(%rsp)
cvtss2sd 0x8(%rsp), %xmm0
callq 0x10d0
mulsd 0x10(%rsp), %xmm0
addsd 0x314f(%rip), %xmm0     # 0x6038
mulsd 0x3b0f(%rip), %xmm0     # 0x6a00
cvtsd2ss %xmm0, %xmm0
movsd (%rbx,%r13,8), %xmm1
callq 0x34df
movlps %xmm0, (%rbx,%r13,8)
movss 0x8(%rsp), %xmm0
incq %r13
addss 0xc(%rsp), %xmm0
jmp 0x2ec5
testl %ebp, %ebp
js 0x2f3d
andl $0x0, (%rbx)
pushq $0x1
popq %r14
cmpq %r15, %r14
jge 0x2f60
xorpd %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x3596
movlpd %xmm0, (%rbx,%r14,8)
incq %r14
jmp 0x2f21
movslq %r14d, %r14
cmpq %r14, %r12
jge 0x2f5c
xorpd %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x3596
movlpd %xmm0, (%rbx,%r12,8)
incq %r12
jmp 0x2f40
andl $0x0, 0x4(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x7082(%rip), %rax      # 0x9ff8
movq (%rax), %rcx
leaq 0x3aaa(%rip), %rdi      # 0x6a2a
pushq $0x19
popq %rsi
pushq $0x1
popq %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1200
// File: /workspace/github_c_makefile_star2_O2/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:
andl $0x0, (%rdx)
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
xorps %xmm0, %xmm0
xorl %eax, %eax
cmpq %rcx, %rsi
je 0x2fc5
movss (%rdi,%rcx,4), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x2fc0
movss %xmm1, (%rdx)
movaps %xmm1, %xmm0
movl %ecx, %eax
incq %rcx
jmp 0x2fa8
retq
// File: /workspace/github_c_makefile_star2_O2/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:
andl $0x0, (%rdx)
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
xorps %xmm1, %xmm1
movaps 0x3086(%rip), %xmm0     # 0x6060
xorl %eax, %eax
cmpq %rcx, %rsi
je 0x3005
movss (%rdi,%rcx,4), %xmm2
movaps %xmm2, %xmm3
andps %xmm0, %xmm3
movaps %xmm1, %xmm4
andps %xmm0, %xmm4
ucomiss %xmm4, %xmm3
jbe 0x3000
movss %xmm2, (%rdx)
movaps %xmm2, %xmm1
movl %ecx, %eax
incq %rcx
jmp 0x2fdc
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %ecx, %ecx
testl %esi, %esi
movl $0x0, %eax
cmovgl %esi, %eax
xorpd %xmm1, %xmm1
cmpq %rcx, %rax
je 0x3037
cvtsi2ss %ecx, %xmm0
movss (%rdi,%rcx,4), %xmm2
mulss %xmm2, %xmm0
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
cvtps2pd %xmm0, %xmm0
addpd %xmm0, %xmm1
incq %rcx
jmp 0x3016
cvtsi2sd %esi, %xmm0
movsd 0x39bd(%rip), %xmm2     # 0x6a00
mulsd %xmm0, %xmm2
leal -0x1(%rsi), %ecx
cvtsi2sd %ecx, %xmm3
mulsd %xmm2, %xmm3
leal -0x1(%rsi,%rsi), %ecx
cvtsi2sd %ecx, %xmm2
mulsd %xmm3, %xmm2
divsd 0x39a2(%rip), %xmm2     # 0x6a08
movapd %xmm3, %xmm4
mulsd %xmm3, %xmm4
movapd %xmm2, %xmm5
mulsd %xmm0, %xmm5
subsd %xmm4, %xmm5
movapd %xmm1, %xmm4
unpckhpd %xmm1, %xmm4            # xmm4 = xmm4[1],xmm1[1]
mulsd %xmm4, %xmm2
mulsd %xmm3, %xmm4
mulsd %xmm1, %xmm0
subsd %xmm4, %xmm0
mulsd %xmm1, %xmm3
subsd %xmm3, %xmm2
divsd %xmm5, %xmm2
xorpd 0x392a(%rip), %xmm0     # 0x69d0
divsd %xmm5, %xmm0
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x30d4
cvtss2sd (%rdi,%rcx,4), %xmm1
cvtsi2sd %ecx, %xmm3
mulsd %xmm0, %xmm3
addsd %xmm1, %xmm3
subsd %xmm2, %xmm3
cvtsd2ss %xmm3, %xmm1
movss %xmm1, (%rdi,%rcx,4)
incq %rcx
jmp 0x30ac
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3903(%rip), %xmm2     # 0x69f0
divsd %xmm1, %xmm2
cvtsd2ss %xmm2, %xmm1
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movslq %esi, %r14
pushq $0x1
popq %r15
movss %xmm1, (%rsp)
cvtss2sd %xmm1, %xmm0
mulsd 0x38e9(%rip), %xmm0     # 0x6a00
divsd 0x8(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
cmpq %r14, %r15
jge 0x3167
movss %xmm1, 0x4(%rsp)
movaps %xmm0, %xmm1
xorps 0x2f3a(%rip), %xmm1     # 0x6070
mulss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm0
callq 0x1220
cvtsd2ss %xmm0, %xmm0
movsd (%rbx,%r15,8), %xmm1
callq 0x34df
movss 0x4(%rsp), %xmm1
movlps %xmm0, (%rbx,%r15,8)
incq %r15
addss (%rsp), %xmm1
jmp 0x310b
movaps 0x2f02(%rip), %xmm1     # 0x6070
xorps %xmm0, %xmm1
mulss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm0
callq 0x1220
cvtss2sd 0x4(%rbx), %xmm1
mulsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x4(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movss %xmm0, 0xc(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x2
popq %rax
movl %eax, %r14d
leal (%r14,%r14), %eax
cmpl %ebp, %r14d
jl 0x31b4
shrl %r14d
leaq (,%r14,8), %rdi
callq 0x1150
movq %rax, %r15
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x31f0
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x3596
movlps %xmm0, (%r15,%r12,8)
incq %r12
jmp 0x31d6
movslq %ebp, %r12
shlq $0x2, %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1120
movss 0x37d7(%rip), %xmm0     # 0x69e4
movq %r15, %rdi
movl %r14d, %esi
callq 0x2274
movq %r15, %rdi
movl %r14d, %esi
movss 0xc(%rsp), %xmm0
callq 0x30d5
movss 0x37af(%rip), %xmm0     # 0x69e0
movq %r15, %rdi
movl %r14d, %esi
callq 0x2274
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1120
// File: /workspace/github_c_makefile_star2_O2/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
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
cvtsi2sd %esi, %xmm0
movsd 0x3771(%rip), %xmm1     # 0x69f0
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
movslq %esi, %r14
pushq $0x1
popq %r15
movss %xmm0, 0x8(%rsp)
movaps %xmm0, %xmm1
movaps %xmm1, %xmm0
mulss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
cmpq %r14, %r15
jge 0x3306
movsd %xmm0, 0x18(%rsp)
movss %xmm1, 0x14(%rsp)
callq 0x10d0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x11d0
cvtsd2ss %xmm0, %xmm1
xorps 0x2d96(%rip), %xmm1     # 0x6070
movss 0x10(%rsp), %xmm0
callq 0x3596
movsd (%rbx,%r15,8), %xmm1
callq 0x3478
movss 0x14(%rsp), %xmm1
movlps %xmm0, (%rbx,%r15,8)
incq %r15
addss 0x8(%rsp), %xmm1
jmp 0x3297
callq 0x10d0
cvtss2sd 0x4(%rbx), %xmm1
mulsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x4(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %r14
xorl %r15d, %r15d
testl %esi, %esi
movl $0x0, %r12d
cmovgl %esi, %r12d
xorps %xmm1, %xmm1
cmpq %r15, %r12
je 0x3373
movsd (%r14,%r15,8), %xmm0
movss %xmm1, 0x4(%rsp)
callq 0x357b
movss 0x4(%rsp), %xmm1
cvtsd2ss %xmm0, %xmm0
mulss %xmm0, %xmm0
addss %xmm0, %xmm1
incq %r15
jmp 0x3346
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_O2/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, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
cvtss2sd %xmm3, %xmm2
mulss %xmm3, %xmm3
cvtss2sd %xmm0, %xmm1
mulss %xmm0, %xmm0
addss %xmm3, %xmm0
cvtss2sd %xmm0, %xmm0
sqrtsd %xmm0, %xmm0
sqrtsd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
movaps %xmm2, %xmm0
callq 0x1180
mulsd 0x34c2(%rip), %xmm0     # 0x6a00
movsd %xmm0, 0x8(%rsp)
callq 0x10d0
movapd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x11d0
movapd 0x20(%rsp), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
movapd 0x10(%rsp), %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm1, %xmm2
cvtpd2ps %xmm2, %xmm0
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3466(%rip), %rsi      # 0x6a70
callq 0x11b0
testq %rax, %rax
je 0x3640
movq %rax, %r14
pushq $0x1
popq %rdx
movl $0x278, %esi            # imm = 0x278
movq %r15, %rdi
movq %rax, %rcx
callq 0x1070
cmpq $0x1, %rax
jne 0x365d
movq %r14, %rdi
callq 0x1090
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x69b1(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x3422(%rip), %rsi      # 0x6a73
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1110
jmp 0x3680
movq 0x6994(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x3418(%rip), %rsi      # 0x6a86
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1110
movq %r14, %rdi
callq 0x1090
pushq $-0x1
popq %rax
jmp 0x363a
// File: /workspace/github_c_makefile_star2_O2/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 0x33d6(%rip), %rsi      # 0x6a70
callq 0x11b0
testq %rax, %rax
je 0x36fc
movq %rax, %r15
pushq $0x1
popq %rdx
movl $0x278, %esi            # imm = 0x278
movq %r14, %rdi
movq %rax, %rcx
callq 0x1070
cmpq $0x1, %rax
jne 0x370f
movl 0x13c(%r14), %r12d
shll $0x2, %r12d
movq %r12, %rdi
callq 0x1150
testq %rax, %rax
je 0x3722
movq %rax, %r14
pushq $0x1
popq %rdx
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x1070
cmpq $0x1, %rax
jne 0x3735
movq %r15, %rdi
callq 0x1090
jmp 0x3753
movq 0x68f5(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x3366(%rip), %rsi      # 0x6a73
jmp 0x3746
movq 0x68e2(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x3366(%rip), %rsi      # 0x6a86
jmp 0x3746
movq 0x68cf(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x3373(%rip), %rsi      # 0x6aa6
jmp 0x3746
movq 0x68bc(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x338b(%rip), %rsi      # 0x6ad1
xorl %r14d, %r14d
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1110
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rdi, %rbx
movl 0x16c(%rsp), %r12d
cmpl $0x4, 0x184(%rsp)
sete %cl
orb $0x2, %cl
shll %cl, %r12d
movq %r12, %rdi
callq 0x1150
testq %rax, %rax
je 0x3843
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1120
leaq 0x3368(%rip), %rsi      # 0x6b1a
movq %rbx, %rdi
callq 0x11b0
movq %rax, %r15
testq %rax, %rax
je 0x3811
leaq 0x30(%rsp), %rdi
pushq $0x1
popq %rdx
movl $0x278, %esi            # imm = 0x278
movq %r15, %rcx
callq 0x1200
cmpq $0x1, %rax
jne 0x381a
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x1200
xorl %ebp, %ebp
cmpq $0x1, %rax
jne 0x3823
movq %r14, %rdi
callq 0x1040
movq %r15, %rdi
callq 0x1090
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3304(%rip), %rsi      # 0x6b1c
jmp 0x382a
leaq 0x3321(%rip), %rsi      # 0x6b42
jmp 0x382a
leaq 0x3344(%rip), %rsi      # 0x6b6e
movq 0x67c7(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1110
pushq $-0x1
popq %rbp
jmp 0x37f6
movq 0x67ae(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x329b(%rip), %rsi      # 0x6aef
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1110
// File: /workspace/github_c_makefile_star2_O2/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 0x336f(%rip), %rsi      # 0x6c14
movl $0x278, %edx            # imm = 0x278
callq 0x1120
movl %ebx, 0x13c(%r14)
movss (%rsp), %xmm2
movss %xmm2, (%r14)
movss 0x4(%rsp), %xmm1
movss %xmm1, 0x14(%r14)
andl $0x0, 0x1c(%r14)
decl %ebx
cvtsi2ss %ebx, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x18(%r14)
movl $0xb, 0x15c(%r14)
pushq $0x1
popq %rax
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_O2/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 0x32e5(%rip), %rsi      # 0x6c14
leaq 0x278(%rsp), %r12
movl $0x278, %edx            # imm = 0x278
movq %r12, %rdi
callq 0x1120
movl %r15d, 0x13c(%r12)
movl $0x4, 0x154(%r12)
andl $0x0, 0x1a4(%r12)
leal (,%r15,8), %edi
callq 0x1150
testq %rax, %rax
je 0x39d0
movq %rax, %r12
shll $0x2, %r15d
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x1120
leaq (%r12,%r15,4), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1120
pushq $0x4f
popq %rcx
leaq 0x278(%rsp), %rsi
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3762
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 0x6621(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x31b7(%rip), %rsi      # 0x6b98
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1110
pushq $-0x1
popq %rax
jmp 0x39bf
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x280, %rsp            # imm = 0x280
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0x8(%rsp), %r13
movq %r13, %rsi
callq 0x3685
movss (%r13), %xmm0
movss %xmm0, (%r12)
movl 0x13c(%r13), %ecx
movl %ecx, (%r15)
movss 0x14(%r13), %xmm0
movss %xmm0, (%r14)
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rdx, %rcx
je 0x3a55
movss (%rax,%rdx,4), %xmm0
movss %xmm0, (%rbx,%rdx,4)
incq %rdx
jmp 0x3a41
movq %rax, %rdi
addq $0x280, %rsp            # imm = 0x280
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/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 0x3182(%rip), %rsi      # 0x6c34
movl $0x11c, %edx            # imm = 0x11C
movq %r12, %rdi
callq 0x1120
leaq 0x314e(%rip), %rax      # 0x6c14
movups 0x3287(%rip), %xmm0     # 0x6d54
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
pushq $0x11
popq %rcx
rep  movsl (%rsi), %es:(%rdi)
movl $0x1a8, %ecx            # imm = 0x1A8
leaq (%r12,%rcx), %rdi
addq %rcx, %rax
movl $0xd0, %edx
movq %rax, %rsi
callq 0x1120
leal -0x1(%r13), %eax
cvtsi2ss %eax, %xmm0
movss 0x280(%rsp), %xmm1
mulss %xmm1, %xmm0
movss 0x284(%rsp), %xmm2
addss %xmm2, %xmm0
movss %xmm1, (%r12)
movups 0x30d5(%rip), %xmm1     # 0x6c18
movups %xmm1, 0x4(%r12)
movss %xmm2, 0x14(%r12)
movss %xmm0, 0x18(%r12)
andl $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)
pushq $0x4f
popq %rcx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3762
addq $0x500, %rsp            # imm = 0x500
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r12
movq %r8, %r15
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 0x3020(%rip), %rsi      # 0x6c34
movl $0x11c, %edx            # imm = 0x11C
movq %r13, %rdi
callq 0x1120
leaq 0x2fec(%rip), %rax      # 0x6c14
movups 0x3125(%rip), %xmm0     # 0x6d54
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
pushq $0x11
popq %rcx
rep  movsl (%rsi), %es:(%rdi)
movl $0x1a8, %ecx            # imm = 0x1A8
leaq (%rcx,%r13), %rdi
addq %rcx, %rax
movl $0xd0, %edx
movq %rax, %rsi
callq 0x1120
leal -0x1(%r14), %eax
cvtsi2ss %eax, %xmm0
movss 0x278(%rsp), %xmm1
mulss %xmm1, %xmm0
movss 0x27c(%rsp), %xmm2
addss %xmm2, %xmm0
movss %xmm1, (%r13)
movups 0x2f75(%rip), %xmm1     # 0x6c18
movups %xmm1, 0x4(%r13)
movss %xmm2, 0x14(%r13)
movss %xmm0, 0x18(%r13)
movl %r14d, 0x13c(%r13)
movabsq $-0x3038ffffffff, %rax  # imm = 0xFFFFCFC700000001
movq %rax, 0x154(%r13)
movl $0xb, 0x15c(%r13)
movl $0x1, 0x1a4(%r13)
movss (%rbp), %xmm0
movss %xmm0, 0xd4(%r13)
movq 0x538(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0xcc(%r13)
addss 0x2d37(%rip), %xmm2     # 0x6a44
movss %xmm2, 0x34(%r13)
movss (%r12), %xmm0
movss (%r15), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
addps 0x2d28(%rip), %xmm1     # 0x6a50
movlps %xmm1, 0x2c(%r13)
andl $0x0, 0x1c(%r13)
movq 0x540(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0xa4(%r13)
pushq $0x4f
popq %rcx
movq %rsp, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq 0x548(%rsp), %rsi
callq 0x3762
addq $0x4f8, %rsp            # imm = 0x4F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2e67(%rip), %rsi      # 0x6c34
movl $0x11c, %edx            # imm = 0x11C
movq %r12, %rdi
callq 0x1120
leaq 0x2e33(%rip), %rax      # 0x6c14
movups 0x2f6c(%rip), %xmm0     # 0x6d54
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
pushq $0x11
popq %rcx
rep  movsl (%rsi), %es:(%rdi)
movl $0x1a8, %ecx            # imm = 0x1A8
leaq (%r12,%rcx), %rdi
addq %rcx, %rax
movl $0xd0, %edx
movq %rax, %rsi
callq 0x1120
leal -0x1(%r15), %eax
cvtsi2ss %eax, %xmm0
movss 0x27c(%rsp), %xmm1
mulss %xmm1, %xmm0
movss 0x280(%rsp), %xmm2
addss %xmm2, %xmm0
movss %xmm1, (%r12)
movups 0x2dba(%rip), %xmm1     # 0x6c18
movups %xmm1, 0x4(%r12)
movss %xmm2, 0x14(%r12)
movss %xmm0, 0x18(%r12)
andl $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)
pushq $0x4f
popq %rcx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3762
addq $0x508, %rsp            # imm = 0x508
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x40, %rsp
movq %rdi, %rbx
cvtss2sd %xmm0, %xmm0
movsd 0x2b11(%rip), %xmm2     # 0x6e90
mulsd %xmm2, %xmm0
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm1, %xmm1
mulsd %xmm2, %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, (%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x11d0
movaps %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x10d0
movaps %xmm0, 0x10(%rsp)
cvtss2sd (%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
callq 0x11d0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, (%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x10d0
cvtsd2ss %xmm0, %xmm0
movaps (%rsp), %xmm1
xorps 0x1c82(%rip), %xmm1     # 0x6070
movss %xmm1, (%rbx)
movss %xmm1, 0x4(%rbx)
andl $0x0, 0x8(%rbx)
movapd 0x10(%rsp), %xmm1
unpcklpd 0x30(%rsp), %xmm1       # xmm1 = xmm1[0],mem[0]
cvtpd2ps %xmm1, %xmm1
shufps $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
mulps %xmm1, %xmm0
movss %xmm0, 0xc(%rbx)
movlps %xmm0, 0x10(%rbx)
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2a59(%rip), %xmm0     # 0x6e90
movq %rdi, %r14
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x11d0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x10d0
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
movss (%r14), %xmm4
subss 0x10(%r14), %xmm4
subss %xmm3, %xmm2
cvtss2sd %xmm4, %xmm4
movsd 0x29f5(%rip), %xmm3     # 0x6e98
mulsd %xmm3, %xmm4
cvtss2sd %xmm2, %xmm5
mulsd %xmm4, %xmm5
movss 0x4(%r14), %xmm4
mulss %xmm1, %xmm4
cvtss2sd %xmm4, %xmm4
subsd %xmm4, %xmm5
cvtsd2ss %xmm5, %xmm4
movss %xmm4, 0x1c(%rbx)
movss %xmm4, 0x18(%rbx)
movss 0x8(%r14), %xmm4
xorps 0x1b94(%rip), %xmm4     # 0x6070
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 0x29cb(%rip), %xmm4     # 0x6ee0
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
cvtsd2ss %xmm2, %xmm1
movss %xmm1, 0x20(%rbx)
mulss 0x14(%r14), %xmm0
mulss 0x8(%r14), %xmm6
subss %xmm6, %xmm0
movss %xmm0, 0x14(%rbx)
andl $0x0, 0x8(%rbx)
movss (%r14), %xmm0
addss 0x10(%r14), %xmm0
addss 0x20(%r14), %xmm0
divss 0x2962(%rip), %xmm0     # 0x6ee4
movss %xmm0, 0x28(%rbx)
movss %xmm0, 0x24(%rbx)
andl $0x0, 0x2c(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x68, %rsp
movl %esi, %ebp
movss %xmm1, 0x20(%rsp)
movq %rdi, %rbx
cvtss2sd %xmm0, %xmm0
mulsd 0x235d(%rip), %xmm0     # 0x6e90
movsd %xmm0, 0x10(%rsp)
callq 0x11d0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x10d0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
cvtss2sd 0x20(%rsp), %xmm0
mulsd 0x2327(%rip), %xmm0     # 0x6e90
movsd %xmm0, 0x38(%rsp)
callq 0x10d0
movapd %xmm0, 0x20(%rsp)
movsd 0x38(%rsp), %xmm0
callq 0x11d0
movaps 0x50(%rsp), %xmm3
movaps 0x10(%rsp), %xmm2
movapd 0x20(%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
cvtpd2ps %xmm1, %xmm0
movaps %xmm3, %xmm1
shufps $0x0, %xmm3, %xmm1      # xmm1 = xmm1[0,0],xmm3[0,0]
mulps %xmm0, %xmm1
movlps %xmm1, 0x40(%rsp)
movss %xmm2, 0x48(%rsp)
cmpl $0x3, %ebp
je 0x4bd6
cmpl $0x2, %ebp
je 0x4bf4
cmpl $0x1, %ebp
jne 0x4c47
movss %xmm1, (%rsp)
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movss %xmm1, 0x4(%rsp)
jmp 0x4c08
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
xorps 0x148c(%rip), %xmm1     # 0x6070
movss %xmm1, (%rsp)
movss %xmm0, 0x4(%rsp)
xorps %xmm2, %xmm2
jmp 0x4c08
unpcklps %xmm2, %xmm2            # xmm2 = xmm2[0,0,1,1]
mulps %xmm0, %xmm2
movlps %xmm2, (%rsp)
xorps 0x146b(%rip), %xmm3     # 0x6070
movaps %xmm3, %xmm2
movss %xmm2, 0x8(%rsp)
xorps %xmm0, %xmm0
xorl %eax, %eax
cmpq $0x3, %rax
je 0x4c64
movss 0x40(%rsp,%rax,4), %xmm1
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x4c3e
movss (%rbx,%rcx,4), %xmm2
mulss %xmm1, %xmm2
mulss (%rsp,%rcx,4), %xmm2
addss %xmm2, %xmm0
incq %rcx
jmp 0x4c21
incq %rax
addq $0xc, %rbx
jmp 0x4c13
movq 0x53aa(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2294(%rip), %rsi      # 0x6eec
movl %ebp, %edx
xorl %eax, %eax
callq 0x1110
xorps %xmm0, %xmm0
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12ed(%rip), %rsi      # 0x60f1
callq 0x1190
testq %rax, %rax
je 0x4e15
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x41dc(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x12cd(%rip), %rsi      # 0x60f3
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1130
pushq $0x1
popq %rdi
callq 0x11c0
// File: /workspace/github_c_makefile_star2_O2/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 %rax
cmpl $0x2, %edi
jge 0x1381
leaq 0x2de6(%rip), %rdi      # 0x4128
callq 0x138c
movq 0x2dda(%rip), %rdi      # 0x4128
leaq 0x2ddb(%rip), %rsi      # 0x4130
callq 0x13c8
movq 0x2dc7(%rip), %rdi      # 0x4128
callq 0x15c0
movq 0x2dbb(%rip), %rdi      # 0x4128
movl 0x8(%rax), %esi
callq 0x14c3
movq %rax, %rdi
callq 0x1050
xorl %eax, %eax
popq %rcx
retq
movq (%rsi), %rdi
callq 0x131c
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rsi
callq 0x10e0
testl %eax, %eax
jne 0x12dd
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
je 0x12d2
movq 0x30(%rsp), %r13
movq %r13, %rdi
callq 0x1100
testq %rax, %rax
je 0x12dd
movq %rax, %r14
leaq 0x1d6a(%rip), %rsi      # 0x3004
movq %rbx, %rdi
callq 0x1110
testq %rax, %rax
je 0x12e0
movq %rax, %r12
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %r13, %rdx
movq %rax, %rcx
callq 0x1080
cmpq %r13, %rax
jne 0x12e3
testq %r15, %r15
je 0x12c8
movq %r13, (%r15)
movq %r12, %rdi
callq 0x10a0
jmp 0x1303
callq 0x1050
movl $0x15, (%rax)
xorl %r14d, %r14d
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x1030
testq %r12, %r12
je 0x12f8
movq %r12, %rdi
callq 0x10a0
movq %rbx, %rdi
callq 0x1120
xorl %r14d, %r14d
movq %r14, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x1cd8(%rip), %rsi      # 0x3007
callq 0x1110
testq %rax, %rax
je 0x136c
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %rax, %rcx
callq 0x1130
movq %rax, %r12
movq %r15, %rdi
callq 0x10a0
cmpq %r14, %r12
jne 0x136c
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x1120
xorl %eax, %eax
jmp 0x1360
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
testb %al, %al
je 0x13e1
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
callq 0x10b0
movq %rax, %r15
leaq 0xca(%rax), %rdi
callq 0x1100
movq %rax, %r14
testq %rax, %rax
je 0x14cd
movb $0x0, (%r14)
cmpl $0x0, 0x3cb4(%rip)      # 0x50c0
je 0x1473
movq %rbx, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x1060
xorl %ebp, %ebp
leaq 0x39a9(%rip), %rbx      # 0x4dd0
cmpq $0x18, %rbp
je 0x145f
movq (%rbp,%rbx), %r13
movq %r13, %rdi
callq 0x10b0
movq %r15, %r12
subq %rax, %r12
jbe 0x1454
addq %r14, %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x1040
testl %eax, %eax
je 0x145a
addq $0x8, %rbp
jmp 0x1427
movb $0x0, (%r12)
movq %r14, %rdi
callq 0x10b0
movw $0x2e, (%r14,%rax)
movq 0x8(%rsp), %rbx
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %r15
movq %rax, 0x10(%r15)
leaq 0x120(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r15)
movq %r14, %rdi
callq 0x10b0
movq %r14, %rdi
addq %rax, %rdi
movl $0xc8, %esi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x1090
movq %r14, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x1120
jmp 0x14b8