void cauchy(double *x, int sigInLength, double fb, double fc, double *psir,
            double *psii, int sigOutLength, double ys) {
  int count;
  double con;
  for (count = 0; count < sigInLength; count++) {
    con = 2 * 3.1415926535897931159980 * x[count] * fc / fb;
    psir[count] =
        (1.0 - con * con) / ((1.0 + con * con) * (1.0 + con * con) * ys);
    psii[count] = -2.0 * con / ((1.0 + con * con) * (1.0 + con * con) * ys);
  }
  return;
}


x86 assembly (clang, -O0):
<cauchy>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movsd  %xmm0,-0x18(%rbp)
movsd  %xmm1,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8d,-0x34(%rbp)
movsd  %xmm2,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1245 <cauchy+0x145>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0xec7(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x20(%rbp),%xmm0
divsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xe76(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  -0x50(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm1
movsd  0xe5c(%rip),%xmm2
addsd  %xmm2,%xmm1
movsd  -0x50(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm3
mulsd  %xmm3,%xmm2
movsd  0xe42(%rip),%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
mulsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xe24(%rip),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm1
movsd  0xe01(%rip),%xmm2
addsd  %xmm2,%xmm1
movsd  -0x50(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm3
mulsd  %xmm3,%xmm2
movsd  0xde7(%rip),%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
mulsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    112d <cauchy+0x2d>
pop    %rbp
ret

x86 assembly (clang, -O2):
<cauchy>:
push   %rbp
push   %r15
push   %r14
push   %rbx
test   %esi,%esi
jle    126d <cauchy+0x16d>
mov    %esi,%r8d
cmp    $0x1,%esi
jne    111d <cauchy+0x1d>
xor    %esi,%esi
jmp    1205 <cauchy+0x105>
lea    (%rcx,%r8,8),%rsi
cmp    %rdx,%rsi
seta   %r15b
lea    (%rdx,%r8,8),%rbx
cmp    %rcx,%rbx
seta   %r14b
lea    (%rdi,%r8,8),%rbp
cmp    %rdx,%rbp
seta   %al
cmp    %rdi,%rbx
seta   %r10b
cmp    %rcx,%rbp
seta   %r9b
cmp    %rdi,%rsi
seta   %r11b
xor    %esi,%esi
test   %r14b,%r15b
jne    1205 <cauchy+0x105>
and    %r10b,%al
jne    1205 <cauchy+0x105>
and    %r11b,%r9b
jne    1205 <cauchy+0x105>
mov    %r8d,%esi
and    $0xfffffffe,%esi
movapd %xmm1,%xmm10
unpcklpd %xmm1,%xmm10
movapd %xmm0,%xmm11
unpcklpd %xmm0,%xmm11
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
xor    %eax,%eax
movapd 0xe64(%rip),%xmm8
movapd 0xe6c(%rip),%xmm4
movapd 0xe73(%rip),%xmm9
nopl   (%rax)
movupd (%rdi,%rax,8),%xmm3
mulpd  %xmm8,%xmm3
mulpd  %xmm10,%xmm3
divpd  %xmm11,%xmm3
movapd %xmm3,%xmm6
mulpd  %xmm3,%xmm6
movapd %xmm4,%xmm7
subpd  %xmm6,%xmm7
addpd  %xmm4,%xmm6
mulpd  %xmm6,%xmm6
mulpd  %xmm5,%xmm6
divpd  %xmm6,%xmm7
movupd %xmm7,(%rdx,%rax,8)
mulpd  %xmm9,%xmm3
divpd  %xmm6,%xmm3
movupd %xmm3,(%rcx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rsi
jne    11b0 <cauchy+0xb0>
cmp    %r8,%rsi
je     126d <cauchy+0x16d>
movsd  0xe22(%rip),%xmm8
movsd  0xe22(%rip),%xmm3
movsd  0xe22(%rip),%xmm5
xchg   %ax,%ax
movsd  (%rdi,%rsi,8),%xmm6
mulsd  %xmm8,%xmm6
mulsd  %xmm1,%xmm6
divsd  %xmm0,%xmm6
movapd %xmm6,%xmm7
mulsd  %xmm6,%xmm7
movapd %xmm3,%xmm4
subsd  %xmm7,%xmm4
addsd  %xmm3,%xmm7
mulsd  %xmm7,%xmm7
mulsd  %xmm2,%xmm7
divsd  %xmm7,%xmm4
movsd  %xmm4,(%rdx,%rsi,8)
mulsd  %xmm5,%xmm6
divsd  %xmm7,%xmm6
movsd  %xmm6,(%rcx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r8
jne    1220 <cauchy+0x120>
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @cauchy(double* %0, i32 %1, double %2, double %3, double* %4, double* %5, i32 %6, double %7) {
%9 = alloca double*
%10 = alloca i32
%11 = alloca double
%12 = alloca double
%13 = alloca double*
%14 = alloca double*
%15 = alloca i32
%16 = alloca double
%17 = alloca i32
%18 = alloca double
store double* %0, double** %9
store i32 %1, i32* %10
store double %2, double* %11
store double %3, double* %12
store double* %4, double** %13
store double* %5, double** %14
store i32 %6, i32* %15
store double %7, double* %16
store i32 0, i32* %17
br label %19
19: ; preds = %68, %8
%20 = load i32, i32* %17
%21 = load i32, i32* %10
%22 = icmp slt i32 %20, %21
br i1 %22, label %23, label %71
23: ; preds = %19
%24 = load double*, double** %9
%25 = load i32, i32* %17
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds double, double* %24, i64 %26
%28 = load double, double* %27
%29 = fmul double 0x401921FB54442D18, %28
%30 = load double, double* %12
%31 = fmul double %29, %30
%32 = load double, double* %11
%33 = fdiv double %31, %32
store double %33, double* %18
%34 = load double, double* %18
%35 = load double, double* %18
%36 = fneg double %34
%37 = call double @llvm.fmuladd.f64(double %36, double %35, double 1.000000e+00)
%38 = load double, double* %18
%39 = load double, double* %18
%40 = call double @llvm.fmuladd.f64(double %38, double %39, double 1.000000e+00)
%41 = load double, double* %18
%42 = load double, double* %18
%43 = call double @llvm.fmuladd.f64(double %41, double %42, double 1.000000e+00)
%44 = fmul double %40, %43
%45 = load double, double* %16
%46 = fmul double %44, %45
%47 = fdiv double %37, %46
%48 = load double*, double** %13
%49 = load i32, i32* %17
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds double, double* %48, i64 %50
store double %47, double* %51
%52 = load double, double* %18
%53 = fmul double -2.000000e+00, %52
%54 = load double, double* %18
%55 = load double, double* %18
%56 = call double @llvm.fmuladd.f64(double %54, double %55, double 1.000000e+00)
%57 = load double, double* %18
%58 = load double, double* %18
%59 = call double @llvm.fmuladd.f64(double %57, double %58, double 1.000000e+00)
%60 = fmul double %56, %59
%61 = load double, double* %16
%62 = fmul double %60, %61
%63 = fdiv double %53, %62
%64 = load double*, double** %14
%65 = load i32, i32* %17
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds double, double* %64, i64 %66
store double %63, double* %67
br label %68
68: ; preds = %23
%69 = load i32, i32* %17
%70 = add nsw i32 %69, 1
store i32 %70, i32* %17
br label %19
71: ; preds = %19
ret void
}

LLVM IR (-O2):
define void @cauchy(double* nocapture %0, i32 %1, double %2, double %3, double* nocapture writeonly %4, double* nocapture writeonly %5, i32 %6, double %7) {
%9 = icmp sgt i32 %1, 0
br i1 %9, label %10, label %81
10: ; preds = %8
%11 = zext i32 %1 to i64
%12 = icmp eq i32 %1, 1
br i1 %12, label %60, label %13
13: ; preds = %10
%14 = getelementptr double, double* %4, i64 %11
%15 = getelementptr double, double* %5, i64 %11
%16 = getelementptr double, double* %0, i64 %11
%17 = icmp ugt double* %15, %4
%18 = icmp ugt double* %14, %5
%19 = and i1 %17, %18
%20 = icmp ugt double* %16, %4
%21 = icmp ugt double* %14, %0
%22 = and i1 %20, %21
%23 = or i1 %19, %22
%24 = icmp ugt double* %16, %5
%25 = icmp ugt double* %15, %0
%26 = and i1 %24, %25
%27 = or i1 %23, %26
br i1 %27, label %60, label %28
28: ; preds = %13
%29 = and i64 %11, 4294967294
%30 = insertelement <2 x double> poison, double %3, i64 0
%31 = shufflevector <2 x double> %30, <2 x double> poison, <2 x i32> zeroinitializer
%32 = insertelement <2 x double> poison, double %2, i64 0
%33 = shufflevector <2 x double> %32, <2 x double> poison, <2 x i32> zeroinitializer
%34 = insertelement <2 x double> poison, double %7, i64 0
%35 = shufflevector <2 x double> %34, <2 x double> poison, <2 x i32> zeroinitializer
br label %36
36: ; preds = %36, %28
%37 = phi i64 [ 0, %28 ], [ %56, %36 ]
%38 = getelementptr inbounds double, double* %0, i64 %37
%39 = bitcast double* %38 to <2 x double>*
%40 = load <2 x double>, <2 x double>* %39
%41 = fmul <2 x double> %40, <double 0x401921FB54442D18, double 0x401921FB54442D18>
%42 = fmul <2 x double> %41, %31
%43 = fdiv <2 x double> %42, %33
%44 = fneg <2 x double> %43
%45 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %44, <2 x double> %43, <2 x double> <double 1.000000e+00, double 1.000000e+00>)
%46 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %43, <2 x double> %43, <2 x double> <double 1.000000e+00, double 1.000000e+00>)
%47 = fmul <2 x double> %46, %46
%48 = fmul <2 x double> %47, %35
%49 = fdiv <2 x double> %45, %48
%50 = getelementptr inbounds double, double* %4, i64 %37
%51 = bitcast double* %50 to <2 x double>*
store <2 x double> %49, <2 x double>* %51
%52 = fmul <2 x double> %43, <double -2.000000e+00, double -2.000000e+00>
%53 = fdiv <2 x double> %52, %48
%54 = getelementptr inbounds double, double* %5, i64 %37
%55 = bitcast double* %54 to <2 x double>*
store <2 x double> %53, <2 x double>* %55
%56 = add nuw i64 %37, 2
%57 = icmp eq i64 %56, %29
br i1 %57, label %58, label %36
58: ; preds = %36
%59 = icmp eq i64 %29, %11
br i1 %59, label %81, label %60
60: ; preds = %13, %10, %58
%61 = phi i64 [ 0, %13 ], [ 0, %10 ], [ %29, %58 ]
br label %62
62: ; preds = %60, %62
%63 = phi i64 [ %79, %62 ], [ %61, %60 ]
%64 = getelementptr inbounds double, double* %0, i64 %63
%65 = load double, double* %64
%66 = fmul double %65, 0x401921FB54442D18
%67 = fmul double %66, %3
%68 = fdiv double %67, %2
%69 = fneg double %68
%70 = tail call double @llvm.fmuladd.f64(double %69, double %68, double 1.000000e+00)
%71 = tail call double @llvm.fmuladd.f64(double %68, double %68, double 1.000000e+00)
%72 = fmul double %71, %71
%73 = fmul double %72, %7
%74 = fdiv double %70, %73
%75 = getelementptr inbounds double, double* %4, i64 %63
store double %74, double* %75
%76 = fmul double %68, -2.000000e+00
%77 = fdiv double %76, %73
%78 = getelementptr inbounds double, double* %5, i64 %63
store double %77, double* %78
%79 = add nuw nsw i64 %63, 1
%80 = icmp eq i64 %79, %11
br i1 %80, label %81, label %62
81: ; preds = %62, %58, %8
ret void
}