int c_lattice_worker(int lm, double *inArr, double *outArr, int arrLen,
                     double sin_, double cos_) {
  int xi, yi;
  double x, y;
  if (lm == 1) {
    xi = arrLen - 1;
    yi = 0;
    x = inArr[xi];
    y = inArr[yi];
    outArr[xi] = x * cos_ + y * sin_;
    outArr[yi] = x * sin_ - y * cos_;
  }
  for (int xnc = lm; xnc < (arrLen - (lm << 1)); xnc += 2) {
    xi = xnc;
    yi = xi + 1;
    x = inArr[xi];
    y = inArr[yi];
    outArr[xi] = x * cos_ + y * sin_;
    outArr[yi] = x * sin_ - y * cos_;
  }
  return 1 - lm;
}


x86 assembly (clang, -O0):
<c_lattice_worker>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movsd  %xmm0,-0x28(%rbp)
movsd  %xmm1,-0x30(%rbp)
cmpl   $0x1,-0x4(%rbp)
jne    11c3 <c_lattice_worker+0xc3>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x30(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x4(%rbp),%edx
shl    $0x1,%edx
sub    %edx,%ecx
cmp    %ecx,%eax
jge    1289 <c_lattice_worker+0x189>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x30(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x4c(%rbp)
jmp    11c9 <c_lattice_worker+0xc9>
mov    $0x1,%eax
sub    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<c_lattice_worker>:
cmp    $0x1,%edi
jne    113c <c_lattice_worker+0x3c>
movslq %ecx,%rax
movsd  -0x8(%rsi,%rax,8),%xmm2
movsd  (%rsi),%xmm3
movapd %xmm3,%xmm4
mulsd  %xmm0,%xmm4
movapd %xmm2,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
movsd  %xmm5,-0x8(%rdx,%rax,8)
mulsd  %xmm1,%xmm3
mulsd  %xmm0,%xmm2
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rdx)
sub    %edi,%ecx
sub    %edi,%ecx
cmp    %edi,%ecx
jle    11e5 <c_lattice_worker+0xe5>
movslq %edi,%rax
movslq %ecx,%r8
mov    %rax,%r9
not    %r9
add    %r8,%r9
cmp    $0x2,%r9
jb     118f <c_lattice_worker+0x8f>
lea    (%rdx,%rax,8),%r10
movabs $0x1ffffffffffffffe,%r11
ff ff 1f
and    %r9,%r11
add    %rax,%r11
lea    (%rsi,%r11,8),%rcx
add    $0x10,%rcx
cmp    %rcx,%r10
jae    11ed <c_lattice_worker+0xed>
lea    (%rdx,%r11,8),%r10
add    $0x10,%r10
lea    (%rsi,%rax,8),%rcx
cmp    %r10,%rcx
jae    11ed <c_lattice_worker+0xed>
mov    %rax,%rcx
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
unpcklpd %xmm0,%xmm1
movapd 0xe5a(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi,%rcx,8),%xmm3
movsd  0x8(%rsi,%rcx,8),%xmm4
movapd %xmm4,%xmm5
xorpd  %xmm0,%xmm5
unpcklpd %xmm5,%xmm4
mulpd  %xmm2,%xmm4
unpcklpd %xmm3,%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,(%rdx,%rcx,8)
add    $0x2,%rcx
cmp    %r8,%rcx
jl     11b0 <c_lattice_worker+0xb0>
mov    $0x1,%eax
sub    %edi,%eax
ret
shr    %r9
add    $0x1,%r9
mov    %r9,%r10
and    $0xfffffffffffffffe,%r10
lea    (%rax,%r10,2),%rcx
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
shl    $0x3,%rax
mov    %r10,%r11
cs nopw 0x0(%rax,%rax,1)
movupd (%rsi,%rax,1),%xmm4
movupd 0x10(%rsi,%rax,1),%xmm5
movapd %xmm4,%xmm6
unpcklpd %xmm5,%xmm6
unpckhpd %xmm5,%xmm4
movapd %xmm3,%xmm5
mulpd  %xmm4,%xmm5
mulpd  %xmm2,%xmm4
movapd %xmm6,%xmm7
mulpd  %xmm3,%xmm7
addpd  %xmm4,%xmm7
mulpd  %xmm2,%xmm6
subpd  %xmm5,%xmm6
movapd %xmm7,%xmm4
unpcklpd %xmm6,%xmm4
movhlps %xmm7,%xmm6
movups %xmm6,0x10(%rdx,%rax,1)
movupd %xmm4,(%rdx,%rax,1)
add    $0x20,%rax
add    $0xfffffffffffffffe,%r11
jne    1220 <c_lattice_worker+0x120>
cmp    %r10,%r9
je     11e5 <c_lattice_worker+0xe5>
jmp    1192 <c_lattice_worker+0x92>

LLVM IR (-O0):
define i32 @c_lattice_worker(i32 %0, double* %1, double* %2, i32 %3, double %4, double %5) {
%7 = alloca i32
%8 = alloca double*
%9 = alloca double*
%10 = alloca i32
%11 = alloca double
%12 = alloca double
%13 = alloca i32
%14 = alloca i32
%15 = alloca double
%16 = alloca double
%17 = alloca i32
store i32 %0, i32* %7
store double* %1, double** %8
store double* %2, double** %9
store i32 %3, i32* %10
store double %4, double* %11
store double %5, double* %12
%18 = load i32, i32* %7
%19 = icmp eq i32 %18, 1
br i1 %19, label %20, label %54
20: ; preds = %6
%21 = load i32, i32* %10
%22 = sub nsw i32 %21, 1
store i32 %22, i32* %13
store i32 0, i32* %14
%23 = load double*, double** %8
%24 = load i32, i32* %13
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds double, double* %23, i64 %25
%27 = load double, double* %26
store double %27, double* %15
%28 = load double*, double** %8
%29 = load i32, i32* %14
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds double, double* %28, i64 %30
%32 = load double, double* %31
store double %32, double* %16
%33 = load double, double* %15
%34 = load double, double* %12
%35 = load double, double* %16
%36 = load double, double* %11
%37 = fmul double %35, %36
%38 = call double @llvm.fmuladd.f64(double %33, double %34, double %37)
%39 = load double*, double** %9
%40 = load i32, i32* %13
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds double, double* %39, i64 %41
store double %38, double* %42
%43 = load double, double* %15
%44 = load double, double* %11
%45 = load double, double* %16
%46 = load double, double* %12
%47 = fmul double %45, %46
%48 = fneg double %47
%49 = call double @llvm.fmuladd.f64(double %43, double %44, double %48)
%50 = load double*, double** %9
%51 = load i32, i32* %14
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds double, double* %50, i64 %52
store double %49, double* %53
br label %54
54: ; preds = %20, %6
%55 = load i32, i32* %7
store i32 %55, i32* %17
br label %56
56: ; preds = %98, %54
%57 = load i32, i32* %17
%58 = load i32, i32* %10
%59 = load i32, i32* %7
%60 = shl i32 %59, 1
%61 = sub nsw i32 %58, %60
%62 = icmp slt i32 %57, %61
br i1 %62, label %63, label %101
63: ; preds = %56
%64 = load i32, i32* %17
store i32 %64, i32* %13
%65 = load i32, i32* %13
%66 = add nsw i32 %65, 1
store i32 %66, i32* %14
%67 = load double*, double** %8
%68 = load i32, i32* %13
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds double, double* %67, i64 %69
%71 = load double, double* %70
store double %71, double* %15
%72 = load double*, double** %8
%73 = load i32, i32* %14
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds double, double* %72, i64 %74
%76 = load double, double* %75
store double %76, double* %16
%77 = load double, double* %15
%78 = load double, double* %12
%79 = load double, double* %16
%80 = load double, double* %11
%81 = fmul double %79, %80
%82 = call double @llvm.fmuladd.f64(double %77, double %78, double %81)
%83 = load double*, double** %9
%84 = load i32, i32* %13
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds double, double* %83, i64 %85
store double %82, double* %86
%87 = load double, double* %15
%88 = load double, double* %11
%89 = load double, double* %16
%90 = load double, double* %12
%91 = fmul double %89, %90
%92 = fneg double %91
%93 = call double @llvm.fmuladd.f64(double %87, double %88, double %92)
%94 = load double*, double** %9
%95 = load i32, i32* %14
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds double, double* %94, i64 %96
store double %93, double* %97
br label %98
98: ; preds = %63
%99 = load i32, i32* %17
%100 = add nsw i32 %99, 2
store i32 %100, i32* %17
br label %56
101: ; preds = %56
%102 = load i32, i32* %7
%103 = sub nsw i32 1, %102
ret i32 %103
}

LLVM IR (-O2):
define i32 @c_lattice_worker(i32 %0, double* nocapture %1, double* nocapture writeonly %2, i32 %3, double %4, double %5) {
%7 = icmp eq i32 %0, 1
br i1 %7, label %8, label %20
8: ; preds = %6
%9 = add nsw i32 %3, -1
%10 = sext i32 %9 to i64
%11 = getelementptr inbounds double, double* %1, i64 %10
%12 = load double, double* %11
%13 = load double, double* %1
%14 = fmul double %13, %4
%15 = tail call double @llvm.fmuladd.f64(double %12, double %5, double %14)
%16 = getelementptr inbounds double, double* %2, i64 %10
store double %15, double* %16
%17 = fneg double %13
%18 = fmul double %17, %5
%19 = tail call double @llvm.fmuladd.f64(double %12, double %4, double %18)
store double %19, double* %2
br label %20
20: ; preds = %8, %6
%21 = mul i32 %0, -2
%22 = add i32 %21, %3
%23 = icmp sgt i32 %22, %0
br i1 %23, label %24, label %80
24: ; preds = %20
%25 = sext i32 %0 to i64
%26 = sext i32 %22 to i64
%27 = xor i64 %25, -1
%28 = add nsw i64 %27, %26
%29 = lshr i64 %28, 1
%30 = add nuw i64 %29, 1
%31 = icmp ult i64 %28, 2
br i1 %31, label %74, label %32
32: ; preds = %24
%33 = getelementptr double, double* %2, i64 %25
%34 = xor i64 %25, -1
%35 = add nsw i64 %34, %26
%36 = and i64 %35, -2
%37 = add nsw i64 %36, %25
%38 = add nsw i64 %37, 2
%39 = getelementptr double, double* %2, i64 %38
%40 = getelementptr double, double* %1, i64 %25
%41 = getelementptr double, double* %1, i64 %38
%42 = icmp ult double* %33, %41
%43 = icmp ult double* %40, %39
%44 = and i1 %42, %43
br i1 %44, label %74, label %45
45: ; preds = %32
%46 = and i64 %30, -2
%47 = shl i64 %46, 1
%48 = add i64 %47, %25
%49 = insertelement <2 x double> poison, double %4, i64 0
%50 = shufflevector <2 x double> %49, <2 x double> poison, <2 x i32> zeroinitializer
%51 = insertelement <2 x double> poison, double %5, i64 0
%52 = shufflevector <2 x double> %51, <2 x double> poison, <2 x i32> zeroinitializer
br label %53
53: ; preds = %53, %45
%54 = phi i64 [ 0, %45 ], [ %70, %53 ]
%55 = shl i64 %54, 1
%56 = add i64 %55, %25
%57 = getelementptr inbounds double, double* %1, i64 %56
%58 = bitcast double* %57 to <4 x double>*
%59 = load <4 x double>, <4 x double>* %58
%60 = shufflevector <4 x double> %59, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%61 = shufflevector <4 x double> %59, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%62 = fmul <2 x double> %61, %50
%63 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %60, <2 x double> %52, <2 x double> %62)
%64 = fneg <2 x double> %61
%65 = fmul <2 x double> %52, %64
%66 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %60, <2 x double> %50, <2 x double> %65)
%67 = getelementptr inbounds double, double* %2, i64 %56
%68 = bitcast double* %67 to <4 x double>*
%69 = shufflevector <2 x double> %63, <2 x double> %66, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %69, <4 x double>* %68
%70 = add nuw i64 %54, 2
%71 = icmp eq i64 %70, %46
br i1 %71, label %72, label %53
72: ; preds = %53
%73 = icmp eq i64 %30, %46
br i1 %73, label %80, label %74
74: ; preds = %32, %24, %72
%75 = phi i64 [ %25, %32 ], [ %25, %24 ], [ %48, %72 ]
%76 = insertelement <2 x double> poison, double %4, i64 0
%77 = insertelement <2 x double> %76, double %5, i64 1
%78 = insertelement <2 x double> poison, double %5, i64 0
%79 = insertelement <2 x double> %78, double %4, i64 1
br label %82
80: ; preds = %82, %72, %20
%81 = sub nsw i32 1, %0
ret i32 %81
82: ; preds = %74, %82
%83 = phi i64 [ %98, %82 ], [ %75, %74 ]
%84 = add nsw i64 %83, 1
%85 = getelementptr inbounds double, double* %1, i64 %83
%86 = load double, double* %85
%87 = getelementptr inbounds double, double* %1, i64 %84
%88 = load double, double* %87
%89 = getelementptr inbounds double, double* %2, i64 %83
%90 = fneg double %88
%91 = insertelement <2 x double> poison, double %88, i64 0
%92 = insertelement <2 x double> %91, double %90, i64 1
%93 = fmul <2 x double> %92, %77
%94 = insertelement <2 x double> poison, double %86, i64 0
%95 = shufflevector <2 x double> %94, <2 x double> poison, <2 x i32> zeroinitializer
%96 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %95, <2 x double> %79, <2 x double> %93)
%97 = bitcast double* %89 to <2 x double>*
store <2 x double> %96, <2 x double>* %97
%98 = add nsw i64 %83, 2
%99 = icmp slt i64 %98, %26
br i1 %99, label %82, label %80
}