void invertLonData(double *array1, double *array2, int gridID1) {
  int nlat, nlon;
  int ilat, ilon;
  double **field1, **field2;
  nlon = gridInqXsize(gridID1);
  nlat = gridInqYsize(gridID1);
  if (nlat > 0) {
    field1 = (double **)Malloc(
        __func__,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/Invert.c",
        259, (nlat * sizeof(double *)));
    field2 = (double **)Malloc(
        __func__,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/Invert.c",
        260, (nlat * sizeof(double *)));
    for (ilat = 0; ilat < nlat; ilat++) {
      field1[ilat] = array1 + ilat * nlon;
      field2[ilat] = array2 + ilat * nlon;
    }
    for (ilat = 0; ilat < nlat; ilat++)
      for (ilon = 0; ilon < nlon; ilon++)
        field2[ilat][nlon - ilon - 1] = field1[ilat][ilon];
    if (field1)
      Free(__func__,
           "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
           "2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/Invert.c",
           272, (field1));
    if (field2)
      Free(__func__,
           "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
           "2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/Invert.c",
           273, (field2));
  } else {
    array2[0] = array1[0];
  }
}


x86 assembly (clang, -O0):
<invertLonData>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%edi
mov    $0x0,%al
call   1050 <gridInqXsize@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%edi
mov    $0x0,%al
call   1040 <gridInqYsize@plt>
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jle    12f8 <invertLonData+0x1b8>
movslq -0x18(%rbp),%rcx
shl    $0x3,%rcx
lea    0xe7a(%rip),%rdi
lea    0xe81(%rip),%rsi
mov    $0x103,%edx
mov    $0x0,%al
call   1030 <Malloc@plt>
cltq
mov    %rax,-0x30(%rbp)
movslq -0x18(%rbp),%rcx
shl    $0x3,%rcx
lea    0xe52(%rip),%rdi
lea    0xe59(%rip),%rsi
mov    $0x104,%edx
mov    $0x0,%al
call   1030 <Malloc@plt>
cltq
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1228 <invertLonData+0xe8>
mov    -0x8(%rbp),%rdx
mov    -0x20(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rdx
mov    -0x20(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11ce <invertLonData+0x8e>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12a1 <invertLonData+0x161>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    128e <invertLonData+0x14e>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x1c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1242 <invertLonData+0x102>
jmp    1293 <invertLonData+0x153>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    122f <invertLonData+0xef>
cmpq   $0x0,-0x30(%rbp)
je     12ca <invertLonData+0x18a>
mov    -0x30(%rbp),%rcx
lea    0xd49(%rip),%rdi
lea    0xd50(%rip),%rsi
mov    $0x110,%edx
mov    $0x0,%al
call   1060 <Free@plt>
cmpq   $0x0,-0x38(%rbp)
je     12f3 <invertLonData+0x1b3>
mov    -0x38(%rbp),%rcx
lea    0xd20(%rip),%rdi
lea    0xd27(%rip),%rsi
mov    $0x111,%edx
mov    $0x0,%al
call   1060 <Free@plt>
jmp    1308 <invertLonData+0x1c8>
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<invertLonData>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %edx,%ebp
mov    %rsi,%r14
mov    %rdi,%rbx
mov    %edx,%edi
xor    %eax,%eax
call   1050 <gridInqXsize@plt>
mov    %eax,%r12d
mov    %ebp,%edi
xor    %eax,%eax
call   1040 <gridInqYsize@plt>
test   %eax,%eax
jle    1543 <invertLonData+0x403>
mov    %r14,(%rsp)
mov    %eax,%ebp
lea    0x0(,%rbp,8),%r15
lea    0xe78(%rip),%rdi
lea    0xe7f(%rip),%rsi
xor    %r13d,%r13d
mov    $0x103,%edx
mov    %r15,%rcx
xor    %eax,%eax
call   1030 <Malloc@plt>
mov    %eax,0x24(%rsp)
movslq %eax,%r14
lea    0xe51(%rip),%rdi
lea    0xe58(%rip),%rsi
mov    $0x104,%edx
mov    %r15,%rcx
xor    %eax,%eax
call   1030 <Malloc@plt>
mov    %rbp,%r10
mov    %eax,0x28(%rsp)
movslq %eax,%r15
mov    %r12,0x38(%rsp)
movslq %r12d,%r8
lea    -0x1(%rbp),%rcx
mov    %r10d,%edx
and    $0x3,%edx
mov    %rdx,0x8(%rsp)
cmp    $0x3,%rcx
mov    %rbp,0x30(%rsp)
jb     1298 <invertLonData+0x158>
and    $0xfffffffc,%r10d
mov    %r10,0x18(%rsp)
mov    %r8,%rsi
shl    $0x4,%rsi
mov    (%rsp),%r10
lea    (%r10,%rsi,1),%rax
mov    %rax,0x10(%rsp)
mov    %r8,%rax
shl    $0x5,%rax
add    %rbx,%rsi
lea    (%r10,%r8,8),%r11
lea    0x0(,%r8,8),%rcx
lea    (%rbx,%r8,8),%rdi
lea    (%rcx,%rcx,2),%rdx
lea    (%r10,%rdx,1),%r9
add    %rbx,%rdx
xor    %ecx,%ecx
xor    %r13d,%r13d
nopl   0x0(%rax)
lea    (%rbx,%rcx,1),%r12
mov    %r12,(%r14,%r13,8)
lea    (%r10,%rcx,1),%rbp
mov    %rbp,(%r15,%r13,8)
lea    (%rdi,%rcx,1),%rbp
mov    %rbp,0x8(%r14,%r13,8)
lea    (%r11,%rcx,1),%rbp
mov    %rbp,0x8(%r15,%r13,8)
lea    (%rsi,%rcx,1),%rbp
mov    %rbp,0x10(%r14,%r13,8)
mov    0x10(%rsp),%rbp
add    %rcx,%rbp
mov    %rbp,0x10(%r15,%r13,8)
lea    (%rdx,%rcx,1),%rbp
mov    %rbp,0x18(%r14,%r13,8)
lea    (%r9,%rcx,1),%rbp
mov    %rbp,0x18(%r15,%r13,8)
add    $0x4,%r13
add    %rax,%rcx
cmp    %r13,0x18(%rsp)
jne    1240 <invertLonData+0x100>
mov    0x8(%rsp),%rax
test   %rax,%rax
je     12d7 <invertLonData+0x197>
lea    (%r15,%r13,8),%rcx
lea    (%r14,%r13,8),%rdx
imul   %r8,%r13
mov    (%rsp),%rsi
lea    (%rsi,%r13,8),%rsi
shl    $0x3,%r8
lea    (%rbx,%r13,8),%rdi
xor    %ebp,%ebp
mov    %rdi,(%rdx,%rbp,8)
mov    %rsi,(%rcx,%rbp,8)
add    $0x1,%rbp
add    %r8,%rsi
add    %r8,%rdi
cmp    %rbp,%rax
jne    12c0 <invertLonData+0x180>
mov    0x38(%rsp),%rcx
mov    %ecx,%r13d
lea    -0x1(%r13),%rax
lea    -0x1(%rcx),%edx
mov    %edx,0x10(%rsp)
movslq %edx,%rsi
lea    0x1(%rsi),%r9
mov    %r9,%rdx
sub    %r13,%rdx
mov    %rdx,(%rsp)
mov    %r13d,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x8(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0x50(%rsp)
mov    %rdx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %esi,%edx
sub    %eax,%edx
cmp    %esi,%edx
setg   %dl
shr    $0x20,%rax
setne  %r11b
or     %dl,%r11b
mov    %rdi,%rax
mov    %rdi,0x48(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x40(%rsp)
mov    %r13,%rax
neg    %rax
mov    %rax,0x18(%rsp)
lea    -0x5(%rcx),%eax
mov    %eax,0x2c(%rsp)
xor    %r12d,%r12d
mov    0x30(%rsp),%rbx
jmp    136d <invertLonData+0x22d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
cmp    %rbx,%r12
je     14ed <invertLonData+0x3ad>
test   %ecx,%ecx
jle    1360 <invertLonData+0x220>
cmp    $0x4,%ecx
setb   %al
mov    (%r14,%r12,8),%r8
mov    (%r15,%r12,8),%r10
or     %r11b,%al
jne    13a6 <invertLonData+0x266>
lea    (%r10,%r9,8),%rax
cmp    %rax,%r8
jae    1421 <invertLonData+0x2e1>
lea    (%r8,%r13,8),%rax
mov    (%rsp),%rdx
lea    (%r10,%rdx,8),%rdx
cmp    %rax,%rdx
jae    1421 <invertLonData+0x2e1>
xor    %eax,%eax
mov    %rax,%rdx
test   $0x1,%r13b
je     13cd <invertLonData+0x28d>
movsd  (%r8,%rax,8),%xmm0
mov    %eax,%edx
not    %edx
add    %ecx,%edx
movslq %edx,%rdx
movsd  %xmm0,(%r10,%rdx,8)
mov    %rax,%rdx
or     $0x1,%rdx
not    %rax
cmp    0x18(%rsp),%rax
je     1360 <invertLonData+0x220>
mov    %r13,%rax
sub    %rdx,%rax
mov    0x10(%rsp),%esi
mov    %esi,%ebp
sub    %edx,%ebp
lea    (%r8,%rdx,8),%rdx
add    $0x8,%rdx
xor    %edi,%edi
nop
movsd  -0x8(%rdx,%rdi,8),%xmm0
movslq %ebp,%rbp
movsd  %xmm0,(%r10,%rbp,8)
movsd  (%rdx,%rdi,8),%xmm0
lea    -0x1(%rbp),%esi
movslq %esi,%rsi
movsd  %xmm0,(%r10,%rsi,8)
add    $0x2,%rdi
add    $0xfffffffe,%ebp
cmp    %rdi,%rax
jne    13f0 <invertLonData+0x2b0>
jmp    1360 <invertLonData+0x220>
mov    %r11d,%edi
mov    %r9,%rdx
cmpq   $0x0,0x50(%rsp)
je     1498 <invertLonData+0x358>
mov    0x40(%rsp),%r9
mov    0x2c(%rsp),%eax
mov    %eax,%r11d
xor    %ebp,%ebp
nopl   (%rax)
movups (%r8,%rbp,8),%xmm0
movups 0x10(%r8,%rbp,8),%xmm1
lea    0x4(%r11),%eax
cltq
shufps $0x4e,%xmm0,%xmm0
movups %xmm0,-0x8(%r10,%rax,8)
shufps $0x4e,%xmm1,%xmm1
movups %xmm1,-0x18(%r10,%rax,8)
movups 0x20(%r8,%rbp,8),%xmm0
movups 0x30(%r8,%rbp,8),%xmm1
movslq %r11d,%r11
shufps $0x4e,%xmm0,%xmm0
movups %xmm0,-0x8(%r10,%r11,8)
shufps $0x4e,%xmm1,%xmm1
movups %xmm1,-0x18(%r10,%r11,8)
add    $0x8,%rbp
add    $0xfffffff8,%r11d
add    $0xfffffffffffffffe,%r9
jne    1440 <invertLonData+0x300>
jmp    149a <invertLonData+0x35a>
xor    %ebp,%ebp
testb  $0x1,0x48(%rsp)
mov    0x38(%rsp),%rcx
je     14cc <invertLonData+0x38c>
movups (%r8,%rbp,8),%xmm0
movups 0x10(%r8,%rbp,8),%xmm1
not    %ebp
add    %ecx,%ebp
movslq %ebp,%rax
shufps $0x4e,%xmm0,%xmm0
movups %xmm0,-0x8(%r10,%rax,8)
shufps $0x4e,%xmm1,%xmm1
movups %xmm1,-0x18(%r10,%rax,8)
mov    0x8(%rsp),%rsi
mov    %rsi,%rax
cmp    %r13,%rsi
mov    0x30(%rsp),%rbx
mov    %rdx,%r9
mov    %edi,%r11d
je     1360 <invertLonData+0x220>
jmp    13a8 <invertLonData+0x268>
cmpl   $0x0,0x24(%rsp)
je     1511 <invertLonData+0x3d1>
lea    0xb05(%rip),%rdi
lea    0xb0c(%rip),%rsi
mov    $0x110,%edx
mov    %r14,%rcx
xor    %eax,%eax
call   1060 <Free@plt>
cmpl   $0x0,0x28(%rsp)
je     154c <invertLonData+0x40c>
lea    0xae1(%rip),%rdi
lea    0xae8(%rip),%rsi
mov    $0x111,%edx
mov    %r15,%rcx
xor    %eax,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1060 <Free@plt>
movsd  (%rbx),%xmm0
movsd  %xmm0,(%r14)
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__func__.invertLonData = [14 x i8] c"invertLonData\00"
@.str = [130 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/Invert.c\00"
define void @invertLonData(double* %0, double* %1, i32 %2) {
%4 = alloca double*
%5 = alloca double*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca double**
%12 = alloca double**
store double* %0, double** %4
store double* %1, double** %5
store i32 %2, i32* %6
%13 = load i32, i32* %6
%14 = call i32 (i32, ...) bitcast (i32 (...)* @gridInqXsize to i32 (i32, ...)*)(i32 %13)
store i32 %14, i32* %8
%15 = load i32, i32* %6
%16 = call i32 (i32, ...) bitcast (i32 (...)* @gridInqYsize to i32 (i32, ...)*)(i32 %15)
store i32 %16, i32* %7
%17 = load i32, i32* %7
%18 = icmp sgt i32 %17, 0
br i1 %18, label %19, label %111
19: ; preds = %3
%20 = load i32, i32* %7
%21 = sext i32 %20 to i64
%22 = mul i64 %21, 8
%23 = call i32 (i8*, i8*, i32, i64, ...) bitcast (i32 (...)* @Malloc to i32 (i8*, i8*, i32, i64, ...)*)(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @__func__.invertLonData, i64 0, i64 0), i8* getelementptr inbounds ([130 x i8], [130 x i8]* @.str, i64 0, i64 0), i32 259, i64 %22)
%24 = sext i32 %23 to i64
%25 = inttoptr i64 %24 to double**
store double** %25, double*** %11
%26 = load i32, i32* %7
%27 = sext i32 %26 to i64
%28 = mul i64 %27, 8
%29 = call i32 (i8*, i8*, i32, i64, ...) bitcast (i32 (...)* @Malloc to i32 (i8*, i8*, i32, i64, ...)*)(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @__func__.invertLonData, i64 0, i64 0), i8* getelementptr inbounds ([130 x i8], [130 x i8]* @.str, i64 0, i64 0), i32 260, i64 %28)
%30 = sext i32 %29 to i64
%31 = inttoptr i64 %30 to double**
store double** %31, double*** %12
store i32 0, i32* %9
br label %32
32: ; preds = %57, %19
%33 = load i32, i32* %9
%34 = load i32, i32* %7
%35 = icmp slt i32 %33, %34
br i1 %35, label %36, label %60
36: ; preds = %32
%37 = load double*, double** %4
%38 = load i32, i32* %9
%39 = load i32, i32* %8
%40 = mul nsw i32 %38, %39
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds double, double* %37, i64 %41
%43 = load double**, double*** %11
%44 = load i32, i32* %9
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds double*, double** %43, i64 %45
store double* %42, double** %46
%47 = load double*, double** %5
%48 = load i32, i32* %9
%49 = load i32, i32* %8
%50 = mul nsw i32 %48, %49
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds double, double* %47, i64 %51
%53 = load double**, double*** %12
%54 = load i32, i32* %9
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds double*, double** %53, i64 %55
store double* %52, double** %56
br label %57
57: ; preds = %36
%58 = load i32, i32* %9
%59 = add nsw i32 %58, 1
store i32 %59, i32* %9
br label %32
60: ; preds = %32
store i32 0, i32* %9
br label %61
61: ; preds = %95, %60
%62 = load i32, i32* %9
%63 = load i32, i32* %7
%64 = icmp slt i32 %62, %63
br i1 %64, label %65, label %98
65: ; preds = %61
store i32 0, i32* %10
br label %66
66: ; preds = %91, %65
%67 = load i32, i32* %10
%68 = load i32, i32* %8
%69 = icmp slt i32 %67, %68
br i1 %69, label %70, label %94
70: ; preds = %66
%71 = load double**, double*** %11
%72 = load i32, i32* %9
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds double*, double** %71, i64 %73
%75 = load double*, double** %74
%76 = load i32, i32* %10
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds double, double* %75, i64 %77
%79 = load double, double* %78
%80 = load double**, double*** %12
%81 = load i32, i32* %9
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds double*, double** %80, i64 %82
%84 = load double*, double** %83
%85 = load i32, i32* %8
%86 = load i32, i32* %10
%87 = sub nsw i32 %85, %86
%88 = sub nsw i32 %87, 1
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds double, double* %84, i64 %89
store double %79, double* %90
br label %91
91: ; preds = %70
%92 = load i32, i32* %10
%93 = add nsw i32 %92, 1
store i32 %93, i32* %10
br label %66
94: ; preds = %66
br label %95
95: ; preds = %94
%96 = load i32, i32* %9
%97 = add nsw i32 %96, 1
store i32 %97, i32* %9
br label %61
98: ; preds = %61
%99 = load double**, double*** %11
%100 = icmp ne double** %99, null
br i1 %100, label %101, label %104
101: ; preds = %98
%102 = load double**, double*** %11
%103 = call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @__func__.invertLonData, i64 0, i64 0), i8* getelementptr inbounds ([130 x i8], [130 x i8]* @.str, i64 0, i64 0), i32 272, double** %102)
br label %104
104: ; preds = %101, %98
%105 = load double**, double*** %12
%106 = icmp ne double** %105, null
br i1 %106, label %107, label %110
107: ; preds = %104
%108 = load double**, double*** %12
%109 = call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @__func__.invertLonData, i64 0, i64 0), i8* getelementptr inbounds ([130 x i8], [130 x i8]* @.str, i64 0, i64 0), i32 273, double** %108)
br label %110
110: ; preds = %107, %104
br label %117
111: ; preds = %3
%112 = load double*, double** %4
%113 = getelementptr inbounds double, double* %112, i64 0
%114 = load double, double* %113
%115 = load double*, double** %5
%116 = getelementptr inbounds double, double* %115, i64 0
store double %114, double* %116
br label %117
117: ; preds = %111, %110
ret void
}

LLVM IR (-O2):
@__func__.invertLonData = [14 x i8] c"invertLonData\00"
@.str = [130 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/Invert.c\00"
define void @invertLonData(double* %0, double* %1, i32 %2) {
%4 = tail call i32 (i32, ...) bitcast (i32 (...)* @gridInqXsize to i32 (i32, ...)*)(i32 %2)
%5 = tail call i32 (i32, ...) bitcast (i32 (...)* @gridInqYsize to i32 (i32, ...)*)(i32 %2)
%6 = icmp sgt i32 %5, 0
br i1 %6, label %7, label %219
7: ; preds = %3
%8 = zext i32 %5 to i64
%9 = shl nuw nsw i64 %8, 3
%10 = tail call i32 (i8*, i8*, i32, i64, ...) bitcast (i32 (...)* @Malloc to i32 (i8*, i8*, i32, i64, ...)*)(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @__func__.invertLonData, i64 0, i64 0), i8* getelementptr inbounds ([130 x i8], [130 x i8]* @.str, i64 0, i64 0), i32 259, i64 %9)
%11 = sext i32 %10 to i64
%12 = inttoptr i64 %11 to double**
%13 = tail call i32 (i8*, i8*, i32, i64, ...) bitcast (i32 (...)* @Malloc to i32 (i8*, i8*, i32, i64, ...)*)(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @__func__.invertLonData, i64 0, i64 0), i8* getelementptr inbounds ([130 x i8], [130 x i8]* @.str, i64 0, i64 0), i32 260, i64 %9)
%14 = sext i32 %13 to i64
%15 = inttoptr i64 %14 to double**
%16 = sext i32 %4 to i64
%17 = add nsw i64 %8, -1
%18 = and i64 %8, 3
%19 = icmp ult i64 %17, 3
br i1 %19, label %22, label %20
20: ; preds = %7
%21 = and i64 %8, 4294967292
br label %64
22: ; preds = %64, %7
%23 = phi i64 [ 0, %7 ], [ %90, %64 ]
%24 = icmp eq i64 %18, 0
br i1 %24, label %36, label %25
25: ; preds = %22, %25
%26 = phi i64 [ %33, %25 ], [ %23, %22 ]
%27 = phi i64 [ %34, %25 ], [ 0, %22 ]
%28 = mul nsw i64 %26, %16
%29 = getelementptr inbounds double, double* %0, i64 %28
%30 = getelementptr inbounds double*, double** %12, i64 %26
store double* %29, double** %30
%31 = getelementptr inbounds double, double* %1, i64 %28
%32 = getelementptr inbounds double*, double** %15, i64 %26
store double* %31, double** %32
%33 = add nuw nsw i64 %26, 1
%34 = add i64 %27, 1
%35 = icmp eq i64 %34, %18
br i1 %35, label %36, label %25
36: ; preds = %25, %22
%37 = icmp sgt i32 %4, 0
%38 = zext i32 %4 to i64
%39 = add nsw i64 %38, -1
%40 = add i32 %4, -1
%41 = sext i32 %40 to i64
%42 = add nsw i64 %41, 1
%43 = sub nsw i64 %42, %38
%44 = add nsw i64 %41, 1
%45 = and i64 %38, 4294967292
%46 = add nsw i64 %45, -4
%47 = lshr exact i64 %46, 2
%48 = add nuw nsw i64 %47, 1
%49 = icmp ult i32 %4, 4
%50 = trunc i64 %39 to i32
%51 = sub i32 %40, %50
%52 = icmp sgt i32 %51, %40
%53 = icmp ugt i64 %39, 4294967295
%54 = or i1 %52, %53
%55 = and i64 %38, 4294967292
%56 = and i64 %48, 1
%57 = icmp eq i64 %46, 0
%58 = and i64 %48, 9223372036854775806
%59 = icmp eq i64 %56, 0
%60 = icmp eq i64 %55, %38
%61 = and i64 %38, 1
%62 = icmp eq i64 %61, 0
%63 = sub nsw i64 0, %38
br label %93
64: ; preds = %64, %20
%65 = phi i64 [ 0, %20 ], [ %90, %64 ]
%66 = phi i64 [ 0, %20 ], [ %91, %64 ]
%67 = mul nsw i64 %65, %16
%68 = getelementptr inbounds double, double* %0, i64 %67
%69 = getelementptr inbounds double*, double** %12, i64 %65
store double* %68, double** %69
%70 = getelementptr inbounds double, double* %1, i64 %67
%71 = getelementptr inbounds double*, double** %15, i64 %65
store double* %70, double** %71
%72 = or i64 %65, 1
%73 = mul nsw i64 %72, %16
%74 = getelementptr inbounds double, double* %0, i64 %73
%75 = getelementptr inbounds double*, double** %12, i64 %72
store double* %74, double** %75
%76 = getelementptr inbounds double, double* %1, i64 %73
%77 = getelementptr inbounds double*, double** %15, i64 %72
store double* %76, double** %77
%78 = or i64 %65, 2
%79 = mul nsw i64 %78, %16
%80 = getelementptr inbounds double, double* %0, i64 %79
%81 = getelementptr inbounds double*, double** %12, i64 %78
store double* %80, double** %81
%82 = getelementptr inbounds double, double* %1, i64 %79
%83 = getelementptr inbounds double*, double** %15, i64 %78
store double* %82, double** %83
%84 = or i64 %65, 3
%85 = mul nsw i64 %84, %16
%86 = getelementptr inbounds double, double* %0, i64 %85
%87 = getelementptr inbounds double*, double** %12, i64 %84
store double* %86, double** %87
%88 = getelementptr inbounds double, double* %1, i64 %85
%89 = getelementptr inbounds double*, double** %15, i64 %84
store double* %88, double** %89
%90 = add nuw nsw i64 %65, 4
%91 = add i64 %66, 4
%92 = icmp eq i64 %91, %21
br i1 %92, label %22, label %64
93: ; preds = %36, %208
%94 = phi i64 [ 0, %36 ], [ %209, %208 ]
br i1 %37, label %95, label %208
95: ; preds = %93
%96 = getelementptr inbounds double*, double** %12, i64 %94
%97 = load double*, double** %96
%98 = getelementptr inbounds double*, double** %15, i64 %94
%99 = load double*, double** %98
%100 = select i1 %49, i1 true, i1 %54
br i1 %100, label %174, label %101
101: ; preds = %95
%102 = getelementptr double, double* %97, i64 %38
%103 = getelementptr double, double* %99, i64 %43
%104 = getelementptr double, double* %99, i64 %44
%105 = icmp ult double* %97, %104
%106 = icmp ult double* %103, %102
%107 = and i1 %105, %106
br i1 %107, label %174, label %108
108: ; preds = %101
br i1 %57, label %152, label %109
109: ; preds = %108, %109
%110 = phi i64 [ %149, %109 ], [ 0, %108 ]
%111 = phi i64 [ %150, %109 ], [ 0, %108 ]
%112 = trunc i64 %110 to i32
%113 = getelementptr inbounds double, double* %97, i64 %110
%114 = bitcast double* %113 to <2 x double>*
%115 = load <2 x double>, <2 x double>* %114
%116 = getelementptr inbounds double, double* %113, i64 2
%117 = bitcast double* %116 to <2 x double>*
%118 = load <2 x double>, <2 x double>* %117
%119 = xor i32 %112, -1
%120 = add i32 %4, %119
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds double, double* %99, i64 %121
%123 = shufflevector <2 x double> %115, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%124 = getelementptr inbounds double, double* %122, i64 -1
%125 = bitcast double* %124 to <2 x double>*
store <2 x double> %123, <2 x double>* %125
%126 = shufflevector <2 x double> %118, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%127 = getelementptr inbounds double, double* %122, i64 -2
%128 = getelementptr inbounds double, double* %127, i64 -1
%129 = bitcast double* %128 to <2 x double>*
store <2 x double> %126, <2 x double>* %129
%130 = or i64 %110, 4
%131 = trunc i64 %130 to i32
%132 = getelementptr inbounds double, double* %97, i64 %130
%133 = bitcast double* %132 to <2 x double>*
%134 = load <2 x double>, <2 x double>* %133
%135 = getelementptr inbounds double, double* %132, i64 2
%136 = bitcast double* %135 to <2 x double>*
%137 = load <2 x double>, <2 x double>* %136
%138 = xor i32 %131, -1
%139 = add i32 %4, %138
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds double, double* %99, i64 %140
%142 = shufflevector <2 x double> %134, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%143 = getelementptr inbounds double, double* %141, i64 -1
%144 = bitcast double* %143 to <2 x double>*
store <2 x double> %142, <2 x double>* %144
%145 = shufflevector <2 x double> %137, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%146 = getelementptr inbounds double, double* %141, i64 -2
%147 = getelementptr inbounds double, double* %146, i64 -1
%148 = bitcast double* %147 to <2 x double>*
store <2 x double> %145, <2 x double>* %148
%149 = add nuw i64 %110, 8
%150 = add i64 %111, 2
%151 = icmp eq i64 %150, %58
br i1 %151, label %152, label %109
152: ; preds = %109, %108
%153 = phi i64 [ 0, %108 ], [ %149, %109 ]
br i1 %59, label %173, label %154
154: ; preds = %152
%155 = trunc i64 %153 to i32
%156 = getelementptr inbounds double, double* %97, i64 %153
%157 = bitcast double* %156 to <2 x double>*
%158 = load <2 x double>, <2 x double>* %157
%159 = getelementptr inbounds double, double* %156, i64 2
%160 = bitcast double* %159 to <2 x double>*
%161 = load <2 x double>, <2 x double>* %160
%162 = xor i32 %155, -1
%163 = add i32 %4, %162
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds double, double* %99, i64 %164
%166 = shufflevector <2 x double> %158, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%167 = getelementptr inbounds double, double* %165, i64 -1
%168 = bitcast double* %167 to <2 x double>*
store <2 x double> %166, <2 x double>* %168
%169 = shufflevector <2 x double> %161, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%170 = getelementptr inbounds double, double* %165, i64 -2
%171 = getelementptr inbounds double, double* %170, i64 -1
%172 = bitcast double* %171 to <2 x double>*
store <2 x double> %169, <2 x double>* %172
br label %173
173: ; preds = %152, %154
br i1 %60, label %208, label %174
174: ; preds = %95, %101, %173
%175 = phi i64 [ 0, %101 ], [ 0, %95 ], [ %55, %173 ]
%176 = xor i64 %175, -1
br i1 %62, label %186, label %177
177: ; preds = %174
%178 = getelementptr inbounds double, double* %97, i64 %175
%179 = load double, double* %178
%180 = trunc i64 %175 to i32
%181 = xor i32 %180, -1
%182 = add i32 %4, %181
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double, double* %99, i64 %183
store double %179, double* %184
%185 = or i64 %175, 1
br label %186
186: ; preds = %177, %174
%187 = phi i64 [ %175, %174 ], [ %185, %177 ]
%188 = icmp eq i64 %176, %63
br i1 %188, label %208, label %189
189: ; preds = %186, %189
%190 = phi i64 [ %206, %189 ], [ %187, %186 ]
%191 = getelementptr inbounds double, double* %97, i64 %190
%192 = load double, double* %191
%193 = trunc i64 %190 to i32
%194 = xor i32 %193, -1
%195 = add i32 %4, %194
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds double, double* %99, i64 %196
store double %192, double* %197
%198 = add nuw nsw i64 %190, 1
%199 = getelementptr inbounds double, double* %97, i64 %198
%200 = load double, double* %199
%201 = trunc i64 %198 to i32
%202 = xor i32 %201, -1
%203 = add i32 %4, %202
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds double, double* %99, i64 %204
store double %200, double* %205
%206 = add nuw nsw i64 %190, 2
%207 = icmp eq i64 %206, %38
br i1 %207, label %208, label %189
208: ; preds = %186, %189, %173, %93
%209 = add nuw nsw i64 %94, 1
%210 = icmp eq i64 %209, %8
br i1 %210, label %211, label %93
211: ; preds = %208
%212 = icmp eq i32 %10, 0
br i1 %212, label %215, label %213
213: ; preds = %211
%214 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @__func__.invertLonData, i64 0, i64 0), i8* getelementptr inbounds ([130 x i8], [130 x i8]* @.str, i64 0, i64 0), i32 272, double** %12)
br label %215
215: ; preds = %213, %211
%216 = icmp eq i32 %13, 0
br i1 %216, label %221, label %217
217: ; preds = %215
%218 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @__func__.invertLonData, i64 0, i64 0), i8* getelementptr inbounds ([130 x i8], [130 x i8]* @.str, i64 0, i64 0), i32 273, double** %15)
br label %221
219: ; preds = %3
%220 = load double, double* %0
store double %220, double* %1
br label %221
221: ; preds = %215, %217, %219
ret void
}