LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x378a(%rip), %xmm2     # 0x6a60
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 0x3437
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
movsd 0x3716(%rip), %xmm1     # 0x6a50
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, (%rsp)
movl %ebp, 0xc(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
xorpd 0x36d3(%rip), %xmm0     # 0x6a30
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 0x2d33(%rip), %xmm0     # 0x60c8
mulsd 0x36c3(%rip), %xmm0     # 0x6a60
cvtsd2ss %xmm0, %xmm0
movsd (%rbp,%r15,8), %xmm1
callq 0x3a27
movss 0x4(%rsp), %xmm1
movlps %xmm0, (%rbp,%r15,8)
addss (%rsp), %xmm1
incq %r15
cmpl %r15d, %r13d
jne 0x3375
cmpl $0x0, 0xc(%rsp)
js 0x3401
movl $0x0, (%rbx)
movl 0x8(%rsp), %eax
cmpl $0x2, %eax
jl 0x3428
movl %eax, %r14d
movl $0x1, %r15d
xorpd %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x3ade
movlpd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x33e5
jmp 0x3428
movslq %r12d, %r15
movslq %r14d, %r14
xorpd %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x3ade
movlpd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq %r14, %r15
jl 0x3407
movl $0x0, 0x4(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1299
jmp 0x3428
// File: /workspace/github_c_makefile_star2_O3/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 0x346d
movl %esi, %ecx
xorl %esi, %esi
xorps %xmm0, %xmm0
xorl %eax, %eax
movss (%rdi,%rsi,4), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x3464
movss %xmm1, (%rdx)
movaps %xmm1, %xmm0
movl %esi, %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x3451
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x34b2
movl %esi, %ecx
xorl %esi, %esi
xorps %xmm1, %xmm1
movaps 0x2b98(%rip), %xmm0     # 0x6020
xorl %eax, %eax
movss (%rdi,%rsi,4), %xmm2
movaps %xmm2, %xmm3
andps %xmm0, %xmm3
movaps %xmm1, %xmm4
andps %xmm0, %xmm4
ucomiss %xmm4, %xmm3
jbe 0x34a9
movss %xmm2, (%rdx)
movaps %xmm2, %xmm1
movl %esi, %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x348a
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
xorpd %xmm0, %xmm0
testl %esi, %esi
jle 0x34e3
xorl %ecx, %ecx
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
movss (%rdi,%rcx,4), %xmm2
mulss %xmm2, %xmm1
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
cvtps2pd %xmm1, %xmm1
addpd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x34c1
testl %esi, %esi
jle 0x359d
leal -0x1(%rsi), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
movsd 0x3563(%rip), %xmm3     # 0x6a60
mulsd %xmm1, %xmm3
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
mulsd %xmm3, %xmm2
leal -0x1(%rsi,%rsi), %ecx
cvtsi2sd %ecx, %xmm5
mulsd %xmm2, %xmm5
divsd 0x3548(%rip), %xmm5     # 0x6a68
movapd 0x3508(%rip), %xmm4     # 0x6a30
xorpd %xmm2, %xmm4
movapd %xmm0, %xmm6
mulsd %xmm2, %xmm6
mulsd %xmm2, %xmm2
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
mulsd %xmm3, %xmm4
mulsd %xmm5, %xmm3
mulsd %xmm1, %xmm5
subsd %xmm2, %xmm5
subsd %xmm6, %xmm3
divsd %xmm5, %xmm3
mulsd %xmm1, %xmm0
addsd %xmm4, %xmm0
xorpd 0x34c8(%rip), %xmm0     # 0x6a30
divsd %xmm5, %xmm0
xorl %ecx, %ecx
xorps %xmm1, %xmm1
cvtss2sd (%rdi,%rcx,4), %xmm1
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
subsd %xmm3, %xmm2
xorps %xmm1, %xmm1
cvtsd2ss %xmm2, %xmm1
movss %xmm1, (%rdi,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x356e
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x349a(%rip), %xmm2     # 0x6a50
divsd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtsd2ss %xmm2, %xmm1
movss %xmm1, (%rsp)
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
cmpl $0x2, %esi
jl 0x364e
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 0x3463(%rip), %xmm0     # 0x6a60
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, %xmm1
xorps 0x2a01(%rip), %xmm1     # 0x6010
mulss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
callq 0x1230
cvtsd2ss %xmm0, %xmm0
movsd (%rbx,%r15,8), %xmm1
callq 0x3a27
movsd 0x8(%rsp), %xmm1
movlps %xmm0, (%rbx,%r15,8)
movss 0x4(%rsp), %xmm0
incq %r15
addss (%rsp), %xmm0
cmpq %r15, %r14
jne 0x35e6
jmp 0x3653
movss (%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0x3401(%rip), %xmm0     # 0x6a60
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movaps 0x29a2(%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_O3/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 0x36be
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 0x3ade
movlps %xmm0, (%r15,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x36eb
movslq %ebp, %r12
shlq $0x2, %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1130
movss 0x3320(%rip), %xmm0     # 0x6a40
movq %r15, %rdi
movl %r14d, %esi
callq 0x254a
movq %r15, %rdi
movl %r14d, %esi
movss 0x4(%rsp), %xmm0
callq 0x359e
movss 0x3300(%rip), %xmm0     # 0x6a44
movq %r15, %rdi
movl %r14d, %esi
callq 0x254a
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_O3/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 0x32bc(%rip), %xmm1     # 0x6a50
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
cmpl $0x2, %esi
jl 0x383c
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 0x280b(%rip), %xmm1     # 0x6010
movss 0x14(%rsp), %xmm0
callq 0x3ade
movsd (%rbx,%r15,8), %xmm1
callq 0x39c0
movss 0x10(%rsp), %xmm2
movlps %xmm0, (%rbx,%r15,8)
movss 0xc(%rsp), %xmm0
incq %r15
addss 0x8(%rsp), %xmm0
cmpq %r15, %r14
jne 0x37c3
jmp 0x3842
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_O3/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 0x38b8
movq %rdi, %r14
movl %ebx, %r15d
xorps %xmm1, %xmm1
xorl %r12d, %r12d
movss %xmm1, 0x4(%rsp)
movsd (%r14,%r12,8), %xmm0
callq 0x3ac3
movss 0x4(%rsp), %xmm1
cvtsd2ss %xmm0, %xmm0
mulss %xmm0, %xmm0
addss %xmm0, %xmm1
incq %r12
cmpq %r12, %r15
jne 0x388b
jmp 0x38bb
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_O3/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 0x1190
mulsd 0x2fda(%rip), %xmm0     # 0x6a60
movsd %xmm0, 0x8(%rsp)
callq 0x10e0
movapd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x11e0
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_O3/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 0x2f7e(%rip), %rsi      # 0x6ad0
callq 0x11c0
testq %rax, %rax
je 0x3b8a
movq %rax, %r14
movl $0x278, %esi            # imm = 0x278
movl $0x1, %edx
movq %r15, %rdi
movq %rax, %rcx
callq 0x1070
cmpq $0x1, %rax
jne 0x3ba7
movq %r14, %rdi
callq 0x1090
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x6467(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2f38(%rip), %rsi      # 0x6ad3
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1120
jmp 0x3bca
movq 0x644a(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2f2e(%rip), %rsi      # 0x6ae6
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1120
movq %r14, %rdi
callq 0x1090
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3b84
// File: /workspace/github_c_makefile_star2_O3/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 0x2eea(%rip), %rsi      # 0x6ad0
callq 0x11c0
testq %rax, %rax
je 0x3c4c
movq %rax, %r15
movl $0x278, %esi            # imm = 0x278
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0x1070
cmpq $0x1, %rax
jne 0x3c5f
movl 0x13c(%r14), %r12d
shll $0x2, %r12d
movq %r12, %rdi
callq 0x1160
testq %rax, %rax
je 0x3c72
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x1070
cmpq $0x1, %rax
jne 0x3c85
movq %r15, %rdi
callq 0x1090
jmp 0x3ca3
movq 0x63a5(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2e76(%rip), %rsi      # 0x6ad3
jmp 0x3c96
movq 0x6392(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2e76(%rip), %rsi      # 0x6ae6
jmp 0x3c96
movq 0x637f(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2e83(%rip), %rsi      # 0x6b06
jmp 0x3c96
movq 0x636c(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2e9b(%rip), %rsi      # 0x6b31
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_O3/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 0x1160
testq %rax, %rax
je 0x3d99
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1130
leaq 0x2e78(%rip), %rsi      # 0x6b7a
movq %rbx, %rdi
callq 0x11c0
movq %rax, %r15
testq %rax, %rax
je 0x3d65
leaq 0x30(%rsp), %rdi
movl $0x278, %esi            # imm = 0x278
movl $0x1, %edx
movq %r15, %rcx
callq 0x1210
cmpq $0x1, %rax
jne 0x3d6e
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x1210
xorl %ebp, %ebp
cmpq $0x1, %rax
jne 0x3d77
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 0x2e10(%rip), %rsi      # 0x6b7c
jmp 0x3d7e
leaq 0x2e2d(%rip), %rsi      # 0x6ba2
jmp 0x3d7e
leaq 0x2e50(%rip), %rsi      # 0x6bce
movq 0x6273(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1120
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x3d4a
movq %rbx, %rdi
callq 0x12b5
// File: /workspace/github_c_makefile_star2_O3/YunyiQian[P]multitel3/sacio.c
// Function: swab4
void	swab4(	char	*pt,
		int	n
	)
{
  int i;
  char temp;
  for(i=0;i<n;i+=4) {
    temp = pt[i+3];
    pt[i+3] = pt[i];
    pt[i] = temp;
    temp = pt[i+2];
    pt[i+2] = pt[i+1];
    pt[i+1] = temp;
  }
}

// Assembly:
testl %esi, %esi
jle 0x3dcd
movl %esi, %eax
xorl %ecx, %ecx
pxor %xmm0, %xmm0
movd (%rdi,%rcx), %xmm1
punpcklbw %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3],xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
pshuflw $0x1b, %xmm1, %xmm1     # xmm1 = xmm1[3,2,1,0,4,5,6,7]
packuswb %xmm1, %xmm1
movd %xmm1, (%rdi,%rcx)
addq $0x4, %rcx
cmpq %rax, %rcx
jb 0x3dad
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2e8b(%rip), %rsi      # 0x6c74
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_O3/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 0x2df9(%rip), %rsi      # 0x6c74
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 0x3f21
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 0x3cb2
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 0x60d0(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x2cc6(%rip), %rsi      # 0x6bf8
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1120
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3f10
// File: /workspace/github_c_makefile_star2_O3/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 0x2c94(%rip), %rsi      # 0x6c94
movl $0x11c, %edx            # imm = 0x11C
movq %r12, %rdi
callq 0x1130
leaq 0x2c60(%rip), %rax      # 0x6c74
movups 0x2d99(%rip), %xmm0     # 0x6db4
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 0x2be2(%rip), %xmm1     # 0x6c78
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 0x3cb2
addq $0x500, %rsp            # imm = 0x500
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2b28(%rip), %rsi      # 0x6c94
movl $0x11c, %edx            # imm = 0x11C
movq %r13, %rdi
callq 0x1130
leaq 0x2af4(%rip), %rax      # 0x6c74
movups 0x2c2d(%rip), %xmm0     # 0x6db4
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 0x2a78(%rip), %xmm1     # 0x6c78
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 0x283a(%rip), %xmm2     # 0x6aa4
movss %xmm2, 0x34(%r13)
movss (%r12), %xmm0
movss (%r15), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
addps 0x282b(%rip), %xmm1     # 0x6ab0
movlps %xmm1, 0x2c(%r13)
movl $0x0, 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 0x3cb2
addq $0x4f8, %rsp            # imm = 0x4F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2965(%rip), %rsi      # 0x6c94
movl $0x11c, %edx            # imm = 0x11C
movq %r12, %rdi
callq 0x1130
leaq 0x2931(%rip), %rax      # 0x6c74
movups 0x2a6a(%rip), %xmm0     # 0x6db4
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 0x28b3(%rip), %xmm1     # 0x6c78
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 0x3cb2
addq $0x508, %rsp            # imm = 0x508
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x25ea(%rip), %xmm2     # 0x6ef0
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 0x11e0
movaps %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x10e0
movaps %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtss2sd (%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
callq 0x11e0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, (%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x10e0
cvtsd2ss %xmm0, %xmm0
movaps (%rsp), %xmm1
xorps 0x1698(%rip), %xmm1     # 0x6010
movss %xmm1, (%rbx)
movss %xmm1, 0x4(%rbx)
movl $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_O3/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 0x252c(%rip), %xmm0     # 0x6ef0
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 0x24c8(%rip), %xmm3     # 0x6ef8
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 0x15a4(%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 0x249b(%rip), %xmm4     # 0x6f40
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 0x242e(%rip), %xmm0     # 0x6f44
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_O3/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 0x1df7(%rip), %xmm0     # 0x6ef0
movsd %xmm0, 0x10(%rsp)
callq 0x11e0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x10e0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x20(%rsp), %xmm0
mulsd 0x1dbe(%rip), %xmm0     # 0x6ef0
movsd %xmm0, 0x38(%rsp)
callq 0x10e0
movapd %xmm0, 0x20(%rsp)
movsd 0x38(%rsp), %xmm0
callq 0x11e0
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 0x519f
cmpl $0x2, %ebp
je 0x51bd
cmpl $0x1, %ebp
jne 0x5213
movss %xmm1, (%rsp)
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movss %xmm1, 0x4(%rsp)
jmp 0x51d1
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
xorps 0xe63(%rip), %xmm1      # 0x6010
movss %xmm1, (%rsp)
movss %xmm0, 0x4(%rsp)
xorps %xmm2, %xmm2
jmp 0x51d1
unpcklps %xmm2, %xmm2            # xmm2 = xmm2[0,0,1,1]
mulps %xmm0, %xmm2
movlps %xmm2, (%rsp)
xorps 0xe42(%rip), %xmm3      # 0x6010
movaps %xmm3, %xmm2
movss %xmm2, 0x8(%rsp)
xorps %xmm0, %xmm0
xorl %eax, %eax
movss 0x40(%rsp,%rax,4), %xmm1
xorl %ecx, %ecx
movss (%rbx,%rcx,4), %xmm2
mulss %xmm1, %xmm2
mulss (%rsp,%rcx,4), %xmm2
addss %xmm2, %xmm0
incq %rcx
cmpq $0x3, %rcx
jne 0x51e4
incq %rax
addq $0xc, %rbx
cmpq $0x3, %rax
jne 0x51dc
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
movq 0x4dde(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x1d28(%rip), %rsi      # 0x6f4c
movl %ebp, %edx
xorl %eax, %eax
callq 0x1120
xorps %xmm0, %xmm0
jmp 0x520c
// File: /workspace/github_c_makefile_star2_O3/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 0xe25(%rip), %rsi       # 0x60f1
callq 0x11a0
testq %rax, %rax
je 0x52dd
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x12dd
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq %rdi, %rbx
movq %rsp, %rsi
callq 0x10e0
testl %eax, %eax
jne 0x12ff
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
je 0x12d8
movq 0x30(%rsp), %r12
movq %r12, %rdi
callq 0x1100
testq %rax, %rax
je 0x12ff
movq %rax, %r15
leaq 0x1d66(%rip), %rsi      # 0x3004
movq %rbx, %rdi
callq 0x1110
testq %rax, %rax
je 0x12e5
movq %rax, %r13
movl $0x1, %esi
movq %r15, %rdi
movq %r12, %rdx
movq %rax, %rcx
callq 0x1080
cmpq %r12, %rax
jne 0x12ef
testq %r14, %r14
je 0x12ce
movq %r12, (%r14)
movq %r13, %rdi
callq 0x10a0
jmp 0x130a
callq 0x1050
movl $0x15, (%rax)
jmp 0x12ff
movq %r15, %rdi
callq 0x1030
jmp 0x12ff
movq %r15, %rdi
callq 0x1030
movq %r13, %rdi
callq 0x10a0
movq %rbx, %rdi
callq 0x1120
xorl %r15d, %r15d
movq %r15, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movq %rdi, %rbx
leaq 0x1cd1(%rip), %rsi      # 0x3007
callq 0x1110
testq %rax, %rax
je 0x1377
movq %rax, %r12
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
callq 0x1130
movq %rax, %r15
movq %r12, %rdi
callq 0x10a0
movl $0x1, %eax
cmpq %r14, %r15
jne 0x1377
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x1120
xorl %eax, %eax
jmp 0x136b
// File: /workspace/github_c_makefile_star2_O3/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 0x13ec
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 0x14d8
movb $0x0, (%r14)
cmpl $0x0, 0x3ca9(%rip)      # 0x50c0
je 0x147e
movq %rbx, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x1060
xorl %ebp, %ebp
leaq 0x399e(%rip), %rbx      # 0x4dd0
movq (%rbp,%rbx), %r13
movq %r13, %rdi
callq 0x10b0
movq %r15, %r12
subq %rax, %r12
jbe 0x1459
addq %r14, %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x1040
testl %eax, %eax
je 0x1465
addq $0x8, %rbp
cmpq $0x18, %rbp
jne 0x1432
jmp 0x146a
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 0x14c3
// File: /workspace/github_c_makefile_star2_O3/kyz[P]amostools/dumpamos.c
// Function: bank_length
uint32_t bank_length(uint8_t *src, size_t len) {
    if (len >= 6 && (amos_leek(src) == ID_AmSp || amos_leek(src) == ID_AmIc)) {
        int num_sprites = amos_deek(&src[4]);
        uint32_t pos = 6, w, h, d;
        while (num_sprites--) {
            if (pos + 10 > len) return 0;
             w = amos_deek(&src[pos+0]) * 2;
             h = amos_deek(&src[pos+2]);
             d = amos_deek(&src[pos+4]);
            pos += 10 +  w * h * d;
        }
        pos += 64; /* include palette */
        return pos > len ? 0 : pos;
    }
    else if (len >= 20 && amos_leek(src) == ID_AmBk) {
        uint32_t bank_len = (amos_leek(&src[8]) & 0x0FFFFFFF) + 20 - 8;
        return bank_len > len ? 0 : bank_len;
    }
    return 0;
}

// Assembly:
xorl %eax, %eax
cmpq $0x6, %rsi
jb 0x15c4
movl (%rdi), %ecx
bswapl %ecx
cmpl $0x416d5370, %ecx       # imm = 0x416D5370
je 0x1502
cmpl $0x416d4963, %ecx       # imm = 0x416D4963
jne 0x157a
movzwl 0x4(%rdi), %ecx
rolw $0x8, %cx
testw %cx, %cx
je 0x15b5
movzwl %cx, %edx
movl $0x6, %r8d
leal 0xa(%r8), %ecx
cmpq %rsi, %rcx
ja 0x15c4
movl %r8d, %r9d
movzbl (%rdi,%r9), %r10d
movzbl 0x1(%rdi,%r9), %r9d
shll $0x9, %r10d
leal 0x2(%r8), %r11d
movzwl (%rdi,%r11), %r11d
rolw $0x8, %r11w
leal (%r10,%r9,2), %r9d
movzwl %r11w, %r10d
imull %r9d, %r10d
addl $0x4, %r8d
movzwl (%rdi,%r8), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r8d
imull %r10d, %r8d
addl %r8d, %ecx
movl %ecx, %r8d
decl %edx
jne 0x151c
addl $0x40, %ecx
jmp 0x15ba
cmpq $0x14, %rsi
jb 0x15c4
cmpl $0x416d426b, %ecx       # imm = 0x416D426B
jne 0x15c4
movzbl 0x8(%rdi), %eax
movzbl 0x9(%rdi), %ecx
shll $0x10, %ecx
movzbl 0xa(%rdi), %edx
shll $0x8, %edx
movzbl 0xb(%rdi), %edi
andl $0xf, %eax
shll $0x18, %eax
orl %ecx, %eax
orl %edi, %eax
leal (%rdx,%rax), %ecx
addl $0xc, %ecx
xorl %eax, %eax
cmpq %rsi, %rcx
jmp 0x15c1
movl $0x46, %ecx
movl %ecx, %edx
xorl %eax, %eax
cmpq %rsi, %rdx
cmovbel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/kyz[P]amostools/dumpamos.c
// Function: bank_number
uint32_t bank_number(uint8_t *src, size_t len) {
    if (len >= 6 && amos_leek(src) == ID_AmSp) {
        return 1; /* Sprites always bank 1 */
    }
    if (len >= 6 && amos_leek(src) == ID_AmIc) {
        return 2; /* Icons always bank 2 */
    }
    if (len >= 20 && amos_leek(src) == ID_AmBk) {
        return amos_deek(&src[4]);
    }
    return 0;
}

// Assembly:
cmpq $0x6, %rsi
jb 0x1603
movl (%rdi), %ecx
bswapl %ecx
cmpl $0x416d4963, %ecx       # imm = 0x416D4963
je 0x1606
movl $0x1, %eax
cmpl $0x416d5370, %ecx       # imm = 0x416D5370
je 0x160b
cmpq $0x14, %rsi
jb 0x1603
movl $0x0, %eax
cmpl $0x416d426b, %ecx       # imm = 0x416D426B
jne 0x160b
movzwl 0x4(%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %eax
retq
xorl %eax, %eax
retq
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/kyz[P]amostools/dumpamos.c
// Function: bank_type
char *bank_type(uint8_t *src, size_t len) {
    if (len >= 6 && amos_leek(src) == ID_AmSp) {
        return "Sprites";
    }
    if (len >= 6 && amos_leek(src) == ID_AmIc) {
        return "Icons";
    }
    if (len >= 20 && amos_leek(src) == ID_AmBk) {
        /* copy bank type, remove space padding */
        static char type[9];
        char *tp = &type[8];
        memcpy(type, &src[12], 8);
        do { *tp-- = 0; } while (*tp == ' ' && tp > &type[0]);
        return type;
    }
    return NULL;
}

// Assembly:
cmpq $0x6, %rsi
jb 0x162e
movl (%rdi), %ecx
bswapl %ecx
cmpl $0x416d4963, %ecx       # imm = 0x416D4963
je 0x1631
cmpl $0x416d5370, %ecx       # imm = 0x416D5370
jne 0x1639
leaq 0x19e8(%rip), %rax      # 0x3015
retq
xorl %eax, %eax
retq
leaq 0x19e5(%rip), %rax      # 0x301d
retq
xorl %eax, %eax
cmpq $0x14, %rsi
jb 0x1638
cmpl $0x416d426b, %ecx       # imm = 0x416D426B
jne 0x1638
movq 0xc(%rdi), %rax
movq %rax, 0x3a74(%rip)      # 0x50c8
leaq 0x3a74(%rip), %rcx      # 0x50cf
leaq 0x3a66(%rip), %rax      # 0x50c8
movb $0x0, 0x1(%rcx)
cmpq %rax, %rcx
jbe 0x1638
cmpb $0x20, (%rcx)
leaq -0x1(%rcx), %rcx
je 0x1662
jmp 0x1638
// File: /workspace/github_c_makefile_star2_O3/kyz[P]amostools/dumpamos.c
// Function: decode_tracker
void decode_tracker(char *fname, uint8_t *src, size_t len) {
    uint32_t mod_len = len - 20;
    char *outname = output_fname(fname, "tracker%02X.mod", bank_number(src, len));
    if (outname) {
        printf("%s: extracting tracker mod %s (%d bytes)\n", fname, outname, mod_len);
        write_file(outname, &src[20], mod_len);
        free(outname);
    }
    else {
        perror(fname);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x15c5
leaq 0xfcb(%rip), %rsi       # 0x3104
movq %r15, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x1383
testq %rax, %rax
je 0x218b
movq %rax, %r12
addl $-0x14, %ebx
leaq 0xfbd(%rip), %rdi       # 0x3114
movq %r15, %rsi
movq %rax, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x10c0
addq $0x14, %r14
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x131e
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1030
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1120
// File: /workspace/github_c_makefile_star2_O3/kyz[P]amostools/dumpamos.c
// Function: amos_bank
void amos_bank(char *fname, uint8_t *src, size_t len) {
    /* get the "real", validated bank length */
    if (!(len = bank_length(src, len))) return;

    if (amos_leek(src) == ID_AmSp) {
        decode_sprites(fname, src, len, "sprite");
    }
    else if (amos_leek(src) == ID_AmIc) {
        decode_sprites(fname, src, len, "icon");
    }
    else if (amos_leek(src) == ID_AmBk) {
        if (!memcmp(&src[12], "Pac.Pic.", 8)) {
            decode_pacpic(fname, src, len);
        }
        else if (!memcmp(&src[12], "Samples ", 8)) {
            decode_samples(fname, src, len);
        }
        else if (!memcmp(&src[12], "Tracker ", 8)) {
            decode_tracker(fname, src, len);
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x14e2
testl %eax, %eax
je 0x2224
movl %eax, %edx
movl (%rbx), %eax
bswapl %eax
cmpl $0x416d426b, %eax       # imm = 0x416D426B
je 0x21f4
cmpl $0x416d4963, %eax       # imm = 0x416D4963
je 0x21db
cmpl $0x416d5370, %eax       # imm = 0x416D5370
jne 0x2224
leaq 0xf65(%rip), %rcx       # 0x313e
jmp 0x21e2
leaq 0xf63(%rip), %rcx       # 0x3145
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1676
movabsq $0x2e6369502e636150, %rax # imm = 0x2E6369502E636150
cmpq %rax, 0xc(%rbx)
je 0x222c
movabsq $0x2073656c706d6153, %rax # imm = 0x2073656C706D6153
cmpq %rax, 0xc(%rbx)
je 0x223e
movabsq $0x2072656b63617254, %rax # imm = 0x2072656B63617254
cmpq %rax, 0xc(%rbx)
je 0x2250
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x196e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1f18
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2116