#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 */
scalar_t__ contains_angle(double, double, double);
double fmax(double, double);
double fmin(double, double);
void get_bounds(double center_x, double center_y, double radius, double start_x,
                double start_y, double end_x, double end_y, double start_angle,
                double arc_angle, double *bounds) {
  double x_min;
  double y_min;
  double x_max;
  double y_max;
  if (arc_angle >= 360.0 || arc_angle <= -360.0) {
    x_min = -radius;
    y_min = -radius;
    x_max = radius;
    y_max = radius;
  } else {
    x_min = fmin(start_x, end_x) - center_x;
    y_min = fmin(start_y, end_y) - center_y;
    x_max = fmax(start_x, end_x) - center_x;
    y_max = fmax(start_y, end_y) - center_y;
    if (contains_angle(start_angle, arc_angle, 0.0)) {
      if (x_min > radius) {
        x_min = radius;
      }
      if (x_max < radius) {
        x_max = radius;
      }
    }
    if (contains_angle(start_angle, arc_angle, 90.0)) {
      if (y_min > radius) {
        y_min = radius;
      }
      if (y_max < radius) {
        y_max = radius;
      }
    }
    if (contains_angle(start_angle, arc_angle, 180.0)) {
      if (x_min > -radius) {
        x_min = -radius;
      }
      if (x_max < -radius) {
        x_max = -radius;
      }
    }
    if (contains_angle(start_angle, arc_angle, 270.0)) {
      if (y_min > -radius) {
        y_min = -radius;
      }
      if (y_max < -radius) {
        y_max = -radius;
      }
    }
  }
  bounds[0] = center_x + x_min;
  bounds[1] = center_y + y_min;
  bounds[2] = bounds[0] + (x_max - x_min);
  bounds[3] = bounds[1] + (y_max - y_min);
}


x86 assembly (clang, -O0):
<get_bounds>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movsd  0x10(%rbp),%xmm8
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  %xmm2,-0x18(%rbp)
movsd  %xmm3,-0x20(%rbp)
movsd  %xmm4,-0x28(%rbp)
movsd  %xmm5,-0x30(%rbp)
movsd  %xmm6,-0x38(%rbp)
movsd  %xmm7,-0x40(%rbp)
mov    %rdi,-0x48(%rbp)
movsd  0x10(%rbp),%xmm0
movsd  0xea9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jae    1174 <get_bounds+0x64>
movsd  0xe9f(%rip),%xmm0
ucomisd 0x10(%rbp),%xmm0
jb     11cf <get_bounds+0xbf>
movsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    14cf <get_bounds+0x3bf>
movsd  -0x20(%rbp),%xmm3
movsd  -0x30(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
minsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
subsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x28(%rbp),%xmm3
movsd  -0x38(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
minsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
subsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x20(%rbp),%xmm3
movsd  -0x30(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
maxsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
subsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x28(%rbp),%xmm3
movsd  -0x38(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
maxsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
subsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  0x10(%rbp),%xmm1
xorps  %xmm2,%xmm2
call   1030 <contains_angle@plt>
cmp    $0x0,%rax
je     12f0 <get_bounds+0x1e0>
movsd  -0x50(%rbp),%xmm0
ucomisd -0x18(%rbp),%xmm0
jbe    12cd <get_bounds+0x1bd>
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x60(%rbp),%xmm1
movsd  -0x18(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    12eb <get_bounds+0x1db>
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    12f0 <get_bounds+0x1e0>
movsd  -0x40(%rbp),%xmm0
movsd  0x10(%rbp),%xmm1
movsd  0xd0e(%rip),%xmm2
call   1030 <contains_angle@plt>
cmp    $0x0,%rax
je     134e <get_bounds+0x23e>
movsd  -0x58(%rbp),%xmm0
ucomisd -0x18(%rbp),%xmm0
jbe    132b <get_bounds+0x21b>
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x18(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1349 <get_bounds+0x239>
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    134e <get_bounds+0x23e>
movsd  -0x40(%rbp),%xmm0
movsd  0x10(%rbp),%xmm1
movsd  0xcb8(%rip),%xmm2
call   1030 <contains_angle@plt>
cmp    $0x0,%rax
je     140c <get_bounds+0x2fc>
movsd  -0x50(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
ucomisd %xmm1,%xmm0
jbe    13bb <get_bounds+0x2ab>
movsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x60(%rbp),%xmm1
movsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    1407 <get_bounds+0x2f7>
movsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    140c <get_bounds+0x2fc>
movsd  -0x40(%rbp),%xmm0
movsd  0x10(%rbp),%xmm1
movsd  0xc02(%rip),%xmm2
call   1030 <contains_angle@plt>
cmp    $0x0,%rax
je     14ca <get_bounds+0x3ba>
movsd  -0x58(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
ucomisd %xmm1,%xmm0
jbe    1479 <get_bounds+0x369>
movsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    14c5 <get_bounds+0x3b5>
movsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    14ca <get_bounds+0x3ba>
jmp    14cf <get_bounds+0x3bf>
movsd  -0x8(%rbp),%xmm0
addsd  -0x50(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x10(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x60(%rbp),%xmm1
subsd  -0x50(%rbp),%xmm1
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x48(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  -0x68(%rbp),%xmm1
subsd  -0x58(%rbp),%xmm1
addsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movsd  %xmm0,0x18(%rax)
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_bounds>:
push   %rbx
sub    $0x80,%rsp
mov    %rdi,%rbx
movsd  0x90(%rsp),%xmm10
ucomisd 0xed2(%rip),%xmm10
jae    133d <get_bounds+0x22d>
movsd  0xecb(%rip),%xmm8
ucomisd %xmm10,%xmm8
jae    133d <get_bounds+0x22d>
movapd %xmm3,%xmm12
cmpunordsd %xmm3,%xmm12
movapd %xmm12,%xmm8
andpd  %xmm5,%xmm8
movapd %xmm5,%xmm9
minsd  %xmm3,%xmm9
andnpd %xmm9,%xmm12
movapd %xmm4,%xmm11
cmpunordsd %xmm4,%xmm11
movapd %xmm6,%xmm9
minsd  %xmm4,%xmm9
ucomisd %xmm3,%xmm3
jp     118b <get_bounds+0x7b>
maxsd  %xmm3,%xmm5
movapd %xmm11,%xmm3
andpd  %xmm6,%xmm3
andnpd %xmm9,%xmm11
orpd   %xmm8,%xmm12
ucomisd %xmm4,%xmm4
movaps %xmm2,0x60(%rsp)
movaps %xmm1,0x50(%rsp)
jp     11b2 <get_bounds+0xa2>
maxsd  %xmm4,%xmm6
movapd %xmm6,0x10(%rsp)
orpd   %xmm3,%xmm11
movapd %xmm11,0x20(%rsp)
subsd  %xmm0,%xmm12
movapd %xmm12,0x30(%rsp)
movapd %xmm0,0x70(%rsp)
subsd  %xmm0,%xmm5
movapd %xmm5,0x40(%rsp)
xorps  %xmm2,%xmm2
movsd  %xmm7,0x8(%rsp)
movapd %xmm7,%xmm0
movapd %xmm10,%xmm1
call   1030 <contains_angle@plt>
test   %rax,%rax
je     1224 <get_bounds+0x114>
movapd 0x60(%rsp),%xmm0
movapd %xmm0,%xmm1
minsd  0x30(%rsp),%xmm1
movapd %xmm1,0x30(%rsp)
movapd 0x40(%rsp),%xmm1
ucomisd %xmm1,%xmm0
jbe    1224 <get_bounds+0x114>
movapd %xmm0,0x40(%rsp)
movapd 0x50(%rsp),%xmm2
movapd 0x10(%rsp),%xmm3
movsd  0x8(%rsp),%xmm0
movsd  0x90(%rsp),%xmm1
movapd 0x20(%rsp),%xmm4
subsd  %xmm2,%xmm4
movapd %xmm4,0x20(%rsp)
subsd  %xmm2,%xmm3
movapd %xmm3,0x10(%rsp)
movsd  0xdaf(%rip),%xmm2
call   1030 <contains_angle@plt>
test   %rax,%rax
je     1293 <get_bounds+0x183>
movapd 0x60(%rsp),%xmm1
movapd %xmm1,%xmm0
minsd  0x20(%rsp),%xmm0
movapd %xmm0,0x20(%rsp)
movapd 0x10(%rsp),%xmm0
ucomisd %xmm0,%xmm1
jbe    1293 <get_bounds+0x183>
movapd %xmm1,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
movsd  0x90(%rsp),%xmm1
movsd  0xd6e(%rip),%xmm2
call   1030 <contains_angle@plt>
test   %rax,%rax
je     12e0 <get_bounds+0x1d0>
movapd 0xd74(%rip),%xmm0
xorpd  0x60(%rsp),%xmm0
movapd %xmm0,%xmm1
minsd  0x30(%rsp),%xmm1
movapd %xmm1,0x30(%rsp)
ucomisd 0x40(%rsp),%xmm0
jbe    12e0 <get_bounds+0x1d0>
movapd %xmm0,0x40(%rsp)
movsd  0x8(%rsp),%xmm0
movsd  0x90(%rsp),%xmm1
movsd  0xd29(%rip),%xmm2
call   1030 <contains_angle@plt>
test   %rax,%rax
je     1353 <get_bounds+0x243>
movapd 0x60(%rsp),%xmm0
xorpd  0xd21(%rip),%xmm0
movapd %xmm0,%xmm4
minsd  0x20(%rsp),%xmm4
movapd 0x10(%rsp),%xmm3
ucomisd %xmm3,%xmm0
jbe    1329 <get_bounds+0x219>
movapd %xmm0,%xmm3
movapd 0x40(%rsp),%xmm2
movapd 0x50(%rsp),%xmm1
movapd 0x70(%rsp),%xmm0
jmp    1371 <get_bounds+0x261>
movapd 0xceb(%rip),%xmm5
xorpd  %xmm2,%xmm5
movapd %xmm5,%xmm4
movapd %xmm2,%xmm3
jmp    1377 <get_bounds+0x267>
movapd 0x20(%rsp),%xmm4
movapd 0x40(%rsp),%xmm2
movapd 0x50(%rsp),%xmm1
movapd 0x70(%rsp),%xmm0
movapd 0x10(%rsp),%xmm3
movapd 0x30(%rsp),%xmm5
addsd  %xmm5,%xmm0
movsd  %xmm0,(%rbx)
subsd  %xmm5,%xmm2
subsd  %xmm4,%xmm3
unpcklpd %xmm0,%xmm4
unpcklpd %xmm2,%xmm1
addpd  %xmm4,%xmm1
movupd %xmm1,0x8(%rbx)
addsd  %xmm3,%xmm1
movsd  %xmm1,0x18(%rbx)
add    $0x80,%rsp
pop    %rbx
ret

LLVM IR (-O0):
define void @get_bounds(double %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, double %8, double* %9) {
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double*
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
store double %0, double* %11
store double %1, double* %12
store double %2, double* %13
store double %3, double* %14
store double %4, double* %15
store double %5, double* %16
store double %6, double* %17
store double %7, double* %18
store double %8, double* %19
store double* %9, double** %20
%25 = load double, double* %19
%26 = fcmp oge double %25, 3.600000e+02
br i1 %26, label %30, label %27
27: ; preds = %10
%28 = load double, double* %19
%29 = fcmp ole double %28, -3.600000e+02
br i1 %29, label %30, label %37
30: ; preds = %27, %10
%31 = load double, double* %13
%32 = fneg double %31
store double %32, double* %21
%33 = load double, double* %13
%34 = fneg double %33
store double %34, double* %22
%35 = load double, double* %13
store double %35, double* %23
%36 = load double, double* %13
store double %36, double* %24
br label %138
37: ; preds = %27
%38 = load double, double* %14
%39 = load double, double* %16
%40 = call double @llvm.minnum.f64(double %38, double %39)
%41 = load double, double* %11
%42 = fsub double %40, %41
store double %42, double* %21
%43 = load double, double* %15
%44 = load double, double* %17
%45 = call double @llvm.minnum.f64(double %43, double %44)
%46 = load double, double* %12
%47 = fsub double %45, %46
store double %47, double* %22
%48 = load double, double* %14
%49 = load double, double* %16
%50 = call double @llvm.maxnum.f64(double %48, double %49)
%51 = load double, double* %11
%52 = fsub double %50, %51
store double %52, double* %23
%53 = load double, double* %15
%54 = load double, double* %17
%55 = call double @llvm.maxnum.f64(double %53, double %54)
%56 = load double, double* %12
%57 = fsub double %55, %56
store double %57, double* %24
%58 = load double, double* %18
%59 = load double, double* %19
%60 = call i64 @contains_angle(double %58, double %59, double 0.000000e+00)
%61 = icmp ne i64 %60, 0
br i1 %61, label %62, label %75
62: ; preds = %37
%63 = load double, double* %21
%64 = load double, double* %13
%65 = fcmp ogt double %63, %64
br i1 %65, label %66, label %68
66: ; preds = %62
%67 = load double, double* %13
store double %67, double* %21
br label %68
68: ; preds = %66, %62
%69 = load double, double* %23
%70 = load double, double* %13
%71 = fcmp olt double %69, %70
br i1 %71, label %72, label %74
72: ; preds = %68
%73 = load double, double* %13
store double %73, double* %23
br label %74
74: ; preds = %72, %68
br label %75
75: ; preds = %74, %37
%76 = load double, double* %18
%77 = load double, double* %19
%78 = call i64 @contains_angle(double %76, double %77, double 9.000000e+01)
%79 = icmp ne i64 %78, 0
br i1 %79, label %80, label %93
80: ; preds = %75
%81 = load double, double* %22
%82 = load double, double* %13
%83 = fcmp ogt double %81, %82
br i1 %83, label %84, label %86
84: ; preds = %80
%85 = load double, double* %13
store double %85, double* %22
br label %86
86: ; preds = %84, %80
%87 = load double, double* %24
%88 = load double, double* %13
%89 = fcmp olt double %87, %88
br i1 %89, label %90, label %92
90: ; preds = %86
%91 = load double, double* %13
store double %91, double* %24
br label %92
92: ; preds = %90, %86
br label %93
93: ; preds = %92, %75
%94 = load double, double* %18
%95 = load double, double* %19
%96 = call i64 @contains_angle(double %94, double %95, double 1.800000e+02)
%97 = icmp ne i64 %96, 0
br i1 %97, label %98, label %115
98: ; preds = %93
%99 = load double, double* %21
%100 = load double, double* %13
%101 = fneg double %100
%102 = fcmp ogt double %99, %101
br i1 %102, label %103, label %106
103: ; preds = %98
%104 = load double, double* %13
%105 = fneg double %104
store double %105, double* %21
br label %106
106: ; preds = %103, %98
%107 = load double, double* %23
%108 = load double, double* %13
%109 = fneg double %108
%110 = fcmp olt double %107, %109
br i1 %110, label %111, label %114
111: ; preds = %106
%112 = load double, double* %13
%113 = fneg double %112
store double %113, double* %23
br label %114
114: ; preds = %111, %106
br label %115
115: ; preds = %114, %93
%116 = load double, double* %18
%117 = load double, double* %19
%118 = call i64 @contains_angle(double %116, double %117, double 2.700000e+02)
%119 = icmp ne i64 %118, 0
br i1 %119, label %120, label %137
120: ; preds = %115
%121 = load double, double* %22
%122 = load double, double* %13
%123 = fneg double %122
%124 = fcmp ogt double %121, %123
br i1 %124, label %125, label %128
125: ; preds = %120
%126 = load double, double* %13
%127 = fneg double %126
store double %127, double* %22
br label %128
128: ; preds = %125, %120
%129 = load double, double* %24
%130 = load double, double* %13
%131 = fneg double %130
%132 = fcmp olt double %129, %131
br i1 %132, label %133, label %136
133: ; preds = %128
%134 = load double, double* %13
%135 = fneg double %134
store double %135, double* %24
br label %136
136: ; preds = %133, %128
br label %137
137: ; preds = %136, %115
br label %138
138: ; preds = %137, %30
%139 = load double, double* %11
%140 = load double, double* %21
%141 = fadd double %139, %140
%142 = load double*, double** %20
%143 = getelementptr inbounds double, double* %142, i64 0
store double %141, double* %143
%144 = load double, double* %12
%145 = load double, double* %22
%146 = fadd double %144, %145
%147 = load double*, double** %20
%148 = getelementptr inbounds double, double* %147, i64 1
store double %146, double* %148
%149 = load double*, double** %20
%150 = getelementptr inbounds double, double* %149, i64 0
%151 = load double, double* %150
%152 = load double, double* %23
%153 = load double, double* %21
%154 = fsub double %152, %153
%155 = fadd double %151, %154
%156 = load double*, double** %20
%157 = getelementptr inbounds double, double* %156, i64 2
store double %155, double* %157
%158 = load double*, double** %20
%159 = getelementptr inbounds double, double* %158, i64 1
%160 = load double, double* %159
%161 = load double, double* %24
%162 = load double, double* %22
%163 = fsub double %161, %162
%164 = fadd double %160, %163
%165 = load double*, double** %20
%166 = getelementptr inbounds double, double* %165, i64 3
store double %164, double* %166
ret void
}

LLVM IR (-O2):
define void @get_bounds(double %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, double %8, double* nocapture writeonly %9) {
%11 = fcmp oge double %8, 3.600000e+02
%12 = fcmp ole double %8, -3.600000e+02
%13 = or i1 %11, %12
br i1 %13, label %14, label %16
14: ; preds = %10
%15 = fneg double %2
br label %64
16: ; preds = %10
%17 = tail call double @llvm.minnum.f64(double %3, double %5)
%18 = fsub double %17, %0
%19 = tail call double @llvm.minnum.f64(double %4, double %6)
%20 = fsub double %19, %1
%21 = tail call double @llvm.maxnum.f64(double %3, double %5)
%22 = fsub double %21, %0
%23 = tail call double @llvm.maxnum.f64(double %4, double %6)
%24 = fsub double %23, %1
%25 = tail call i64 @contains_angle(double %7, double %8, double 0.000000e+00)
%26 = icmp eq i64 %25, 0
br i1 %26, label %32, label %27
27: ; preds = %16
%28 = fcmp ogt double %18, %2
%29 = select i1 %28, double %2, double %18
%30 = fcmp olt double %22, %2
br i1 %30, label %31, label %32
31: ; preds = %27
br label %32
32: ; preds = %27, %31, %16
%33 = phi double [ %29, %31 ], [ %29, %27 ], [ %18, %16 ]
%34 = phi double [ %2, %31 ], [ %22, %27 ], [ %22, %16 ]
%35 = tail call i64 @contains_angle(double %7, double %8, double 9.000000e+01)
%36 = icmp eq i64 %35, 0
br i1 %36, label %42, label %37
37: ; preds = %32
%38 = fcmp ogt double %20, %2
%39 = select i1 %38, double %2, double %20
%40 = fcmp olt double %24, %2
br i1 %40, label %41, label %42
41: ; preds = %37
br label %42
42: ; preds = %37, %41, %32
%43 = phi double [ %39, %41 ], [ %39, %37 ], [ %20, %32 ]
%44 = phi double [ %2, %41 ], [ %24, %37 ], [ %24, %32 ]
%45 = tail call i64 @contains_angle(double %7, double %8, double 1.800000e+02)
%46 = icmp eq i64 %45, 0
br i1 %46, label %53, label %47
47: ; preds = %42
%48 = fneg double %2
%49 = fcmp ogt double %33, %48
%50 = select i1 %49, double %48, double %33
%51 = fcmp olt double %34, %48
br i1 %51, label %52, label %53
52: ; preds = %47
br label %53
53: ; preds = %47, %52, %42
%54 = phi double [ %50, %52 ], [ %50, %47 ], [ %33, %42 ]
%55 = phi double [ %48, %52 ], [ %34, %47 ], [ %34, %42 ]
%56 = tail call i64 @contains_angle(double %7, double %8, double 2.700000e+02)
%57 = icmp eq i64 %56, 0
br i1 %57, label %64, label %58
58: ; preds = %53
%59 = fneg double %2
%60 = fcmp ogt double %43, %59
%61 = select i1 %60, double %59, double %43
%62 = fcmp olt double %44, %59
br i1 %62, label %63, label %64
63: ; preds = %58
br label %64
64: ; preds = %53, %63, %58, %14
%65 = phi double [ %15, %14 ], [ %54, %63 ], [ %54, %58 ], [ %54, %53 ]
%66 = phi double [ %15, %14 ], [ %61, %63 ], [ %61, %58 ], [ %43, %53 ]
%67 = phi double [ %2, %14 ], [ %55, %63 ], [ %55, %58 ], [ %55, %53 ]
%68 = phi double [ %2, %14 ], [ %59, %63 ], [ %44, %58 ], [ %44, %53 ]
%69 = fadd double %65, %0
store double %69, double* %9
%70 = getelementptr inbounds double, double* %9, i64 1
%71 = fsub double %67, %65
%72 = insertelement <2 x double> poison, double %66, i64 0
%73 = insertelement <2 x double> %72, double %69, i64 1
%74 = insertelement <2 x double> poison, double %1, i64 0
%75 = insertelement <2 x double> %74, double %71, i64 1
%76 = fadd <2 x double> %73, %75
%77 = bitcast double* %70 to <2 x double>*
store <2 x double> %76, <2 x double>* %77
%78 = fsub double %68, %66
%79 = extractelement <2 x double> %76, i64 0
%80 = fadd double %79, %78
%81 = getelementptr inbounds double, double* %9, i64 3
store double %80, double* %81
ret void
}