#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double dmax(double, double);
double fabs(double);
long get_round(double);
int /*<<< orphan*/ max_dmatrix(double **, long, int, double *);
int /*<<< orphan*/ min_dmatrix(double **, long, int, double *);
int /*<<< orphan*/ move_position(double **, long, int, double *);
void adjust_xy(long num, double **xyz, long nO, double **oxyz,
               double scale_factor, long default_size, long *urxy) {
  long i, j;
  double temp;
  double max_xy[3], min_xy[3];
  max_dmatrix(xyz, num, 2, max_xy);
  min_dmatrix(xyz, num, 2, min_xy);
  temp = dmax(max_xy[1] - min_xy[1], max_xy[2] - min_xy[2]);
  scale_factor = fabs(scale_factor);
  if (scale_factor < 1.0e-7)
    scale_factor = default_size / temp;
  move_position(xyz, num, 2, min_xy);
  for (i = 1; i <= num; i++)
    for (j = 1; j <= 2; j++)
      xyz[i][j] *= scale_factor;
  if (nO) {
    move_position(oxyz, nO, 2, min_xy);
    for (i = 1; i <= nO; i++)
      for (j = 1; j <= 2; j++)
        oxyz[i][j] *= scale_factor;
  }
  max_dmatrix(xyz, num, 2, max_xy);
  for (i = 1; i <= 2; i++)
    urxy[i] = get_round(max_xy[i]);
}


x86 assembly (clang, -O0):
<adjust_xy>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x8(%rbp),%rsi
lea    -0x70(%rbp),%rcx
mov    $0x2,%edx
call   1030 <max_dmatrix@plt>
mov    -0x10(%rbp),%rdi
mov    -0x8(%rbp),%rsi
lea    -0x90(%rbp),%rcx
mov    $0x2,%edx
call   1050 <min_dmatrix@plt>
movsd  -0x68(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm1
subsd  -0x80(%rbp),%xmm1
call   1070 <dmax@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x28(%rbp),%xmm0
movaps 0xe3c(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  0xe1b(%rip),%xmm0
ucomisd -0x28(%rbp),%xmm0
jbe    1200 <adjust_xy+0xb0>
cvtsi2sdq -0x30(%rbp),%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x8(%rbp),%rsi
lea    -0x90(%rbp),%rcx
mov    $0x2,%edx
call   1040 <move_position@plt>
movq   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x8(%rbp),%rax
jg     1288 <adjust_xy+0x138>
movq   $0x1,-0x48(%rbp)
cmpq   $0x2,-0x48(%rbp)
jg     1272 <adjust_xy+0x122>
movsd  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1237 <adjust_xy+0xe7>
jmp    1277 <adjust_xy+0x127>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1221 <adjust_xy+0xd1>
cmpq   $0x0,-0x18(%rbp)
je     1320 <adjust_xy+0x1d0>
mov    -0x20(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    -0x90(%rbp),%rcx
mov    $0x2,%edx
call   1040 <move_position@plt>
movq   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x18(%rbp),%rax
jg     131b <adjust_xy+0x1cb>
movq   $0x1,-0x48(%rbp)
cmpq   $0x2,-0x48(%rbp)
jg     1305 <adjust_xy+0x1b5>
movsd  -0x28(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    12ca <adjust_xy+0x17a>
jmp    130a <adjust_xy+0x1ba>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    12b4 <adjust_xy+0x164>
jmp    1320 <adjust_xy+0x1d0>
mov    -0x10(%rbp),%rdi
mov    -0x8(%rbp),%rsi
lea    -0x70(%rbp),%rcx
mov    $0x2,%edx
call   1030 <max_dmatrix@plt>
movq   $0x1,-0x40(%rbp)
cmpq   $0x2,-0x40(%rbp)
jg     1378 <adjust_xy+0x228>
mov    -0x40(%rbp),%rax
movsd  -0x70(%rbp,%rax,8),%xmm0
call   1060 <get_round@plt>
mov    %rax,%rdx
mov    -0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    133e <adjust_xy+0x1ee>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<adjust_xy>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9,%r14
mov    %r8,%rbp
movaps %xmm0,(%rsp)
mov    %rcx,%r12
mov    %rdx,%r13
mov    %rsi,%rbx
mov    %rdi,%r15
lea    0x10(%rsp),%rcx
mov    %rsi,%rdi
mov    %r15,%rsi
mov    $0x2,%edx
call   1030 <max_dmatrix@plt>
lea    0x30(%rsp),%rcx
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x2,%edx
call   1050 <min_dmatrix@plt>
movsd  0x18(%rsp),%xmm0
movsd  0x20(%rsp),%xmm1
subsd  0x38(%rsp),%xmm0
subsd  0x40(%rsp),%xmm1
call   1070 <dmax@plt>
movapd (%rsp),%xmm2
andpd  0xe38(%rip),%xmm2
movsd  0xe40(%rip),%xmm1
ucomisd %xmm2,%xmm1
jbe    11e9 <adjust_xy+0x99>
xorps  %xmm1,%xmm1
cvtsi2sd %rbp,%xmm1
divsd  %xmm0,%xmm1
movapd %xmm1,(%rsp)
jmp    11ee <adjust_xy+0x9e>
movapd %xmm2,(%rsp)
lea    0x30(%rsp),%rcx
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x2,%edx
call   1040 <move_position@plt>
test   %r15,%r15
movapd (%rsp),%xmm2
jle    12cb <adjust_xy+0x17b>
lea    -0x1(%r15),%rdx
mov    %r15d,%eax
and    $0x3,%eax
mov    $0x1,%ecx
cmp    $0x3,%rdx
jb     1299 <adjust_xy+0x149>
mov    %r15,%rdx
and    $0xfffffffffffffffc,%rdx
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    0x8(%rbx,%rcx,8),%rsi
movupd 0x8(%rsi),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x8(%rsi)
mov    0x10(%rbx,%rcx,8),%rsi
movupd 0x8(%rsi),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x8(%rsi)
mov    0x18(%rbx,%rcx,8),%rsi
movupd 0x8(%rsi),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x8(%rsi)
mov    0x20(%rbx,%rcx,8),%rsi
movupd 0x8(%rsi),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x8(%rsi)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1240 <adjust_xy+0xf0>
add    $0x1,%rcx
test   %rax,%rax
je     12cb <adjust_xy+0x17b>
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
lea    (%rbx,%rcx,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax)
mov    (%rcx,%rdx,8),%rsi
movupd 0x8(%rsi),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x8(%rsi)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    12b0 <adjust_xy+0x160>
test   %r13,%r13
je     13ab <adjust_xy+0x25b>
lea    0x30(%rsp),%rcx
mov    %r12,%rdi
mov    %r13,%rsi
mov    $0x2,%edx
call   1040 <move_position@plt>
movapd (%rsp),%xmm2
test   %r13,%r13
jle    13ab <adjust_xy+0x25b>
lea    -0x1(%r13),%rdx
mov    %r13d,%eax
and    $0x3,%eax
mov    $0x1,%ecx
cmp    $0x3,%rdx
jb     1379 <adjust_xy+0x229>
and    $0xfffffffffffffffc,%r13
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    0x8(%r12,%rcx,8),%rdx
movupd 0x8(%rdx),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x8(%rdx)
mov    0x10(%r12,%rcx,8),%rdx
movupd 0x8(%rdx),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x8(%rdx)
mov    0x18(%r12,%rcx,8),%rdx
movupd 0x8(%rdx),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x8(%rdx)
mov    0x20(%r12,%rcx,8),%rdx
movupd 0x8(%rdx),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x8(%rdx)
add    $0x4,%rcx
cmp    %rcx,%r13
jne    1320 <adjust_xy+0x1d0>
add    $0x1,%rcx
test   %rax,%rax
je     13ab <adjust_xy+0x25b>
unpcklpd %xmm2,%xmm2
lea    (%r12,%rcx,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    (%rcx,%rdx,8),%rsi
movupd 0x8(%rsi),%xmm0
mulpd  %xmm2,%xmm0
movupd %xmm0,0x8(%rsi)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1390 <adjust_xy+0x240>
lea    0x10(%rsp),%rcx
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x2,%edx
call   1030 <max_dmatrix@plt>
movsd  0x18(%rsp),%xmm0
call   1060 <get_round@plt>
mov    %rax,0x8(%r14)
movsd  0x20(%rsp),%xmm0
call   1060 <get_round@plt>
mov    %rax,0x10(%r14)
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @adjust_xy(i64 %0, double** %1, i64 %2, double** %3, double %4, i64 %5, i64* %6) {
%8 = alloca i64
%9 = alloca double**
%10 = alloca i64
%11 = alloca double**
%12 = alloca double
%13 = alloca i64
%14 = alloca i64*
%15 = alloca i64
%16 = alloca i64
%17 = alloca double
%18 = alloca [3 x double]
%19 = alloca [3 x double]
store i64 %0, i64* %8
store double** %1, double*** %9
store i64 %2, i64* %10
store double** %3, double*** %11
store double %4, double* %12
store i64 %5, i64* %13
store i64* %6, i64** %14
%20 = load double**, double*** %9
%21 = load i64, i64* %8
%22 = getelementptr inbounds [3 x double], [3 x double]* %18, i64 0, i64 0
%23 = call i32 @max_dmatrix(double** %20, i64 %21, i32 2, double* %22)
%24 = load double**, double*** %9
%25 = load i64, i64* %8
%26 = getelementptr inbounds [3 x double], [3 x double]* %19, i64 0, i64 0
%27 = call i32 @min_dmatrix(double** %24, i64 %25, i32 2, double* %26)
%28 = getelementptr inbounds [3 x double], [3 x double]* %18, i64 0, i64 1
%29 = load double, double* %28
%30 = getelementptr inbounds [3 x double], [3 x double]* %19, i64 0, i64 1
%31 = load double, double* %30
%32 = fsub double %29, %31
%33 = getelementptr inbounds [3 x double], [3 x double]* %18, i64 0, i64 2
%34 = load double, double* %33
%35 = getelementptr inbounds [3 x double], [3 x double]* %19, i64 0, i64 2
%36 = load double, double* %35
%37 = fsub double %34, %36
%38 = call double @dmax(double %32, double %37)
store double %38, double* %17
%39 = load double, double* %12
%40 = call double @llvm.fabs.f64(double %39)
store double %40, double* %12
%41 = load double, double* %12
%42 = fcmp olt double %41, 0x3E7AD7F29ABCAF48
br i1 %42, label %43, label %48
43: ; preds = %7
%44 = load i64, i64* %13
%45 = sitofp i64 %44 to double
%46 = load double, double* %17
%47 = fdiv double %45, %46
store double %47, double* %12
br label %48
48: ; preds = %43, %7
%49 = load double**, double*** %9
%50 = load i64, i64* %8
%51 = getelementptr inbounds [3 x double], [3 x double]* %19, i64 0, i64 0
%52 = call i32 @move_position(double** %49, i64 %50, i32 2, double* %51)
store i64 1, i64* %15
br label %53
53: ; preds = %75, %48
%54 = load i64, i64* %15
%55 = load i64, i64* %8
%56 = icmp sle i64 %54, %55
br i1 %56, label %57, label %78
57: ; preds = %53
store i64 1, i64* %16
br label %58
58: ; preds = %71, %57
%59 = load i64, i64* %16
%60 = icmp sle i64 %59, 2
br i1 %60, label %61, label %74
61: ; preds = %58
%62 = load double, double* %12
%63 = load double**, double*** %9
%64 = load i64, i64* %15
%65 = getelementptr inbounds double*, double** %63, i64 %64
%66 = load double*, double** %65
%67 = load i64, i64* %16
%68 = getelementptr inbounds double, double* %66, i64 %67
%69 = load double, double* %68
%70 = fmul double %69, %62
store double %70, double* %68
br label %71
71: ; preds = %61
%72 = load i64, i64* %16
%73 = add nsw i64 %72, 1
store i64 %73, i64* %16
br label %58
74: ; preds = %58
br label %75
75: ; preds = %74
%76 = load i64, i64* %15
%77 = add nsw i64 %76, 1
store i64 %77, i64* %15
br label %53
78: ; preds = %53
%79 = load i64, i64* %10
%80 = icmp ne i64 %79, 0
br i1 %80, label %81, label %112
81: ; preds = %78
%82 = load double**, double*** %11
%83 = load i64, i64* %10
%84 = getelementptr inbounds [3 x double], [3 x double]* %19, i64 0, i64 0
%85 = call i32 @move_position(double** %82, i64 %83, i32 2, double* %84)
store i64 1, i64* %15
br label %86
86: ; preds = %108, %81
%87 = load i64, i64* %15
%88 = load i64, i64* %10
%89 = icmp sle i64 %87, %88
br i1 %89, label %90, label %111
90: ; preds = %86
store i64 1, i64* %16
br label %91
91: ; preds = %104, %90
%92 = load i64, i64* %16
%93 = icmp sle i64 %92, 2
br i1 %93, label %94, label %107
94: ; preds = %91
%95 = load double, double* %12
%96 = load double**, double*** %11
%97 = load i64, i64* %15
%98 = getelementptr inbounds double*, double** %96, i64 %97
%99 = load double*, double** %98
%100 = load i64, i64* %16
%101 = getelementptr inbounds double, double* %99, i64 %100
%102 = load double, double* %101
%103 = fmul double %102, %95
store double %103, double* %101
br label %104
104: ; preds = %94
%105 = load i64, i64* %16
%106 = add nsw i64 %105, 1
store i64 %106, i64* %16
br label %91
107: ; preds = %91
br label %108
108: ; preds = %107
%109 = load i64, i64* %15
%110 = add nsw i64 %109, 1
store i64 %110, i64* %15
br label %86
111: ; preds = %86
br label %112
112: ; preds = %111, %78
%113 = load double**, double*** %9
%114 = load i64, i64* %8
%115 = getelementptr inbounds [3 x double], [3 x double]* %18, i64 0, i64 0
%116 = call i32 @max_dmatrix(double** %113, i64 %114, i32 2, double* %115)
store i64 1, i64* %15
br label %117
117: ; preds = %128, %112
%118 = load i64, i64* %15
%119 = icmp sle i64 %118, 2
br i1 %119, label %120, label %131
120: ; preds = %117
%121 = load i64, i64* %15
%122 = getelementptr inbounds [3 x double], [3 x double]* %18, i64 0, i64 %121
%123 = load double, double* %122
%124 = call i64 @get_round(double %123)
%125 = load i64*, i64** %14
%126 = load i64, i64* %15
%127 = getelementptr inbounds i64, i64* %125, i64 %126
store i64 %124, i64* %127
br label %128
128: ; preds = %120
%129 = load i64, i64* %15
%130 = add nsw i64 %129, 1
store i64 %130, i64* %15
br label %117
131: ; preds = %117
ret void
}

LLVM IR (-O2):
define void @adjust_xy(i64 %0, double** %1, i64 %2, double** %3, double %4, i64 %5, i64* nocapture writeonly %6) {
%8 = alloca [3 x double]
%9 = alloca [3 x double]
%10 = bitcast [3 x double]* %8 to i8*
%11 = bitcast [3 x double]* %9 to i8*
%12 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 0
%13 = call i32 @max_dmatrix(double** %1, i64 %0, i32 2, double* %12)
%14 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 0
%15 = call i32 @min_dmatrix(double** %1, i64 %0, i32 2, double* %14)
%16 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 1
%17 = load double, double* %16
%18 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 1
%19 = load double, double* %18
%20 = fsub double %17, %19
%21 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 2
%22 = load double, double* %21
%23 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 2
%24 = load double, double* %23
%25 = fsub double %22, %24
%26 = call double @dmax(double %20, double %25)
%27 = call double @llvm.fabs.f64(double %4)
%28 = fcmp olt double %27, 0x3E7AD7F29ABCAF48
br i1 %28, label %29, label %32
29: ; preds = %7
%30 = sitofp i64 %5 to double
%31 = fdiv double %30, %26
br label %32
32: ; preds = %29, %7
%33 = phi double [ %31, %29 ], [ %27, %7 ]
%34 = call i32 @move_position(double** %1, i64 %0, i32 2, double* %14)
%35 = icmp slt i64 %0, 1
br i1 %35, label %106, label %36
36: ; preds = %32
%37 = add i64 %0, -1
%38 = and i64 %0, 3
%39 = icmp ult i64 %37, 3
br i1 %39, label %87, label %40
40: ; preds = %36
%41 = and i64 %0, -4
%42 = insertelement <2 x double> poison, double %33, i64 0
%43 = shufflevector <2 x double> %42, <2 x double> poison, <2 x i32> zeroinitializer
%44 = insertelement <2 x double> poison, double %33, i64 0
%45 = shufflevector <2 x double> %44, <2 x double> poison, <2 x i32> zeroinitializer
%46 = insertelement <2 x double> poison, double %33, i64 0
%47 = shufflevector <2 x double> %46, <2 x double> poison, <2 x i32> zeroinitializer
%48 = insertelement <2 x double> poison, double %33, i64 0
%49 = shufflevector <2 x double> %48, <2 x double> poison, <2 x i32> zeroinitializer
br label %50
50: ; preds = %50, %40
%51 = phi i64 [ 1, %40 ], [ %84, %50 ]
%52 = phi i64 [ 0, %40 ], [ %85, %50 ]
%53 = getelementptr inbounds double*, double** %1, i64 %51
%54 = load double*, double** %53
%55 = getelementptr inbounds double, double* %54, i64 1
%56 = bitcast double* %55 to <2 x double>*
%57 = load <2 x double>, <2 x double>* %56
%58 = fmul <2 x double> %43, %57
%59 = bitcast double* %55 to <2 x double>*
store <2 x double> %58, <2 x double>* %59
%60 = add nuw nsw i64 %51, 1
%61 = getelementptr inbounds double*, double** %1, i64 %60
%62 = load double*, double** %61
%63 = getelementptr inbounds double, double* %62, i64 1
%64 = bitcast double* %63 to <2 x double>*
%65 = load <2 x double>, <2 x double>* %64
%66 = fmul <2 x double> %45, %65
%67 = bitcast double* %63 to <2 x double>*
store <2 x double> %66, <2 x double>* %67
%68 = add nuw nsw i64 %51, 2
%69 = getelementptr inbounds double*, double** %1, i64 %68
%70 = load double*, double** %69
%71 = getelementptr inbounds double, double* %70, i64 1
%72 = bitcast double* %71 to <2 x double>*
%73 = load <2 x double>, <2 x double>* %72
%74 = fmul <2 x double> %47, %73
%75 = bitcast double* %71 to <2 x double>*
store <2 x double> %74, <2 x double>* %75
%76 = add nuw i64 %51, 3
%77 = getelementptr inbounds double*, double** %1, i64 %76
%78 = load double*, double** %77
%79 = getelementptr inbounds double, double* %78, i64 1
%80 = bitcast double* %79 to <2 x double>*
%81 = load <2 x double>, <2 x double>* %80
%82 = fmul <2 x double> %49, %81
%83 = bitcast double* %79 to <2 x double>*
store <2 x double> %82, <2 x double>* %83
%84 = add nuw i64 %51, 4
%85 = add i64 %52, 4
%86 = icmp eq i64 %85, %41
br i1 %86, label %87, label %50
87: ; preds = %50, %36
%88 = phi i64 [ 1, %36 ], [ %84, %50 ]
%89 = icmp eq i64 %38, 0
br i1 %89, label %106, label %90
90: ; preds = %87
%91 = insertelement <2 x double> poison, double %33, i64 0
%92 = shufflevector <2 x double> %91, <2 x double> poison, <2 x i32> zeroinitializer
br label %93
93: ; preds = %93, %90
%94 = phi i64 [ %103, %93 ], [ %88, %90 ]
%95 = phi i64 [ %104, %93 ], [ 0, %90 ]
%96 = getelementptr inbounds double*, double** %1, i64 %94
%97 = load double*, double** %96
%98 = getelementptr inbounds double, double* %97, i64 1
%99 = bitcast double* %98 to <2 x double>*
%100 = load <2 x double>, <2 x double>* %99
%101 = fmul <2 x double> %92, %100
%102 = bitcast double* %98 to <2 x double>*
store <2 x double> %101, <2 x double>* %102
%103 = add nuw i64 %94, 1
%104 = add i64 %95, 1
%105 = icmp eq i64 %104, %38
br i1 %105, label %106, label %93
106: ; preds = %87, %93, %32
%107 = icmp eq i64 %2, 0
br i1 %107, label %181, label %108
108: ; preds = %106
%109 = call i32 @move_position(double** %3, i64 %2, i32 2, double* %14)
%110 = icmp slt i64 %2, 1
br i1 %110, label %181, label %111
111: ; preds = %108
%112 = add i64 %2, -1
%113 = and i64 %2, 3
%114 = icmp ult i64 %112, 3
br i1 %114, label %162, label %115
115: ; preds = %111
%116 = and i64 %2, -4
%117 = insertelement <2 x double> poison, double %33, i64 0
%118 = shufflevector <2 x double> %117, <2 x double> poison, <2 x i32> zeroinitializer
%119 = insertelement <2 x double> poison, double %33, i64 0
%120 = shufflevector <2 x double> %119, <2 x double> poison, <2 x i32> zeroinitializer
%121 = insertelement <2 x double> poison, double %33, i64 0
%122 = shufflevector <2 x double> %121, <2 x double> poison, <2 x i32> zeroinitializer
%123 = insertelement <2 x double> poison, double %33, i64 0
%124 = shufflevector <2 x double> %123, <2 x double> poison, <2 x i32> zeroinitializer
br label %125
125: ; preds = %125, %115
%126 = phi i64 [ 1, %115 ], [ %159, %125 ]
%127 = phi i64 [ 0, %115 ], [ %160, %125 ]
%128 = getelementptr inbounds double*, double** %3, i64 %126
%129 = load double*, double** %128
%130 = getelementptr inbounds double, double* %129, i64 1
%131 = bitcast double* %130 to <2 x double>*
%132 = load <2 x double>, <2 x double>* %131
%133 = fmul <2 x double> %118, %132
%134 = bitcast double* %130 to <2 x double>*
store <2 x double> %133, <2 x double>* %134
%135 = add nuw nsw i64 %126, 1
%136 = getelementptr inbounds double*, double** %3, i64 %135
%137 = load double*, double** %136
%138 = getelementptr inbounds double, double* %137, i64 1
%139 = bitcast double* %138 to <2 x double>*
%140 = load <2 x double>, <2 x double>* %139
%141 = fmul <2 x double> %120, %140
%142 = bitcast double* %138 to <2 x double>*
store <2 x double> %141, <2 x double>* %142
%143 = add nuw nsw i64 %126, 2
%144 = getelementptr inbounds double*, double** %3, i64 %143
%145 = load double*, double** %144
%146 = getelementptr inbounds double, double* %145, i64 1
%147 = bitcast double* %146 to <2 x double>*
%148 = load <2 x double>, <2 x double>* %147
%149 = fmul <2 x double> %122, %148
%150 = bitcast double* %146 to <2 x double>*
store <2 x double> %149, <2 x double>* %150
%151 = add nuw i64 %126, 3
%152 = getelementptr inbounds double*, double** %3, i64 %151
%153 = load double*, double** %152
%154 = getelementptr inbounds double, double* %153, i64 1
%155 = bitcast double* %154 to <2 x double>*
%156 = load <2 x double>, <2 x double>* %155
%157 = fmul <2 x double> %124, %156
%158 = bitcast double* %154 to <2 x double>*
store <2 x double> %157, <2 x double>* %158
%159 = add nuw i64 %126, 4
%160 = add i64 %127, 4
%161 = icmp eq i64 %160, %116
br i1 %161, label %162, label %125
162: ; preds = %125, %111
%163 = phi i64 [ 1, %111 ], [ %159, %125 ]
%164 = icmp eq i64 %113, 0
br i1 %164, label %181, label %165
165: ; preds = %162
%166 = insertelement <2 x double> poison, double %33, i64 0
%167 = shufflevector <2 x double> %166, <2 x double> poison, <2 x i32> zeroinitializer
br label %168
168: ; preds = %168, %165
%169 = phi i64 [ %178, %168 ], [ %163, %165 ]
%170 = phi i64 [ %179, %168 ], [ 0, %165 ]
%171 = getelementptr inbounds double*, double** %3, i64 %169
%172 = load double*, double** %171
%173 = getelementptr inbounds double, double* %172, i64 1
%174 = bitcast double* %173 to <2 x double>*
%175 = load <2 x double>, <2 x double>* %174
%176 = fmul <2 x double> %167, %175
%177 = bitcast double* %173 to <2 x double>*
store <2 x double> %176, <2 x double>* %177
%178 = add nuw i64 %169, 1
%179 = add i64 %170, 1
%180 = icmp eq i64 %179, %113
br i1 %180, label %181, label %168
181: ; preds = %162, %168, %108, %106
%182 = call i32 @max_dmatrix(double** %1, i64 %0, i32 2, double* %12)
%183 = load double, double* %16
%184 = call i64 @get_round(double %183)
%185 = getelementptr inbounds i64, i64* %6, i64 1
store i64 %184, i64* %185
%186 = load double, double* %21
%187 = call i64 @get_round(double %186)
%188 = getelementptr inbounds i64, i64* %6, i64 2
store i64 %187, i64* %188
ret void
}