#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 */
float cos(float);
double fabsl(double);
double pow(float, int);
int /*<<< orphan*/ printf(char *, float, ...);
scalar_t__ sin(float);
double tan(double);
float x2pnts(float **, int, int, float);
int main(void) {
  double d = 0.0000001;
  double e_charge = 0.00000000000000000016021765;
  double e_mass = 0.00000000000000000000000000000091093819;
  double Plancks = 0.0000000000000000000000000000000006626068;
  double Coulomb = 0.00000000898755179;
  double pi = 3.14159265358979;
  double const_e = 2.71828182845905;
  double chargeratio = 0;
  double lambda = 0.00000000001;
  double energy = (1.5 * pow(10, -18) / (pow(lambda, 2)));
  double width = 4 * pow(10, -8);
  double thick = 14 * pow(10, -9);
  double wedgeangle = 0;
  double tilt = 0;
  double res = 1000;
  double eta = width / d;
  double vel = pow(2 * energy * e_charge / e_mass, 1 / 2);
  double alpha = wedgeangle * pi / 180;
  double beta = tilt * pi;
  double eta1 = .4;
  double eta2 = .4;
  double r0 = -4.04;
  double el0 = 0.000001;
  double w0 = 0.00003;
  double G1_z = 0.000001;
  double G2_z = 1;
  double G2_x = 0.00000005;
  double theta = 0;
  long double xmin;
  long double xmax;
  double zstart = -0.1;
  double zend = 2.1;
  double xstart = -200 * pow(10, -6);
  double xend = 200 * pow(10, -6);
  double ystart = -0.11 * pow(10, -3);
  double yend = 0.11 * pow(10, -3);
  double xpnts = 300;
  double ypnts = 300;
  double zpnts = 300;
  double zres = (zend - zstart) / zpnts;
  double w1;
  double r1;
  double el1;
  double el2;
  float fc;
  float ph;
  float ex;
  int j;
  float ReT[41][2] = {{0}};
  for (int i = 0; i <= 41; i++) {
    ReT[i][0] = i - 20;
  }
  float ImT[41][2] = {{0}};
  for (int i = 0; i <= 41; i++) {
    ImT[i][0] = i - 20;
  }
  if (beta >= 0) {
    xmin = width * (1 / res - cos(beta) / 2);
    if (beta <= alpha) {
      xmax = (width * cos(beta)) / 2 - width / res;
    } else {
      xmax = width * cos(beta) / 2 - width / res +
             thick * (tan(alpha) - tan(beta));
    }
  } else {
    xmax = (width * cos(beta) / 2) - width / res;
    if (fabsl(beta) <= alpha) {
      xmin = -((width * cos(beta)) / 2) + width / res;
    } else {
      xmin = -((width * cos(beta)) / 2) + width / res -
             thick * (tan(alpha) - tan(beta));
    }
  }
  for (int n = -20; n <= 20; n++) {
    for (ex = xmin; ex < xmax; ex += width / res) {
      fc = 2 * pi * n * ex / d;
      ph = -width * thick * chargeratio * pow(e_charge, 2) *
           (2 * pi * Coulomb / Plancks) /
           (vel * (.25 * pow(width, 2) - pow(ex, 2)));
      j = n + 20;
      ReT[j][1] += cos(ph + fc);
      ImT[j][1] += sin(ph + fc);
    }
  }
  for (int i = 0; i <= 40; i++) {
    ReT[i][1] = ReT[i][1] / res;
    ImT[i][1] = ImT[i][1] / res;
    printf("value of ReT is: %f and j is: %d \n", ReT[i][1], (i - 20));
  }
  float index, value;
  int rows, columns;
  value = -16;
  index = x2pnts(ReT, 41, 2, value);
  int i2 = index;
  if (index == -1) {
    printf("The value %f was not found.\n", value);
  } else {
    printf("The value %f was found at %f\n", value, index);
    printf(" the equivalent is: %f\n", ReT[i2 - 1][1]);
  }
  value = 13;
  index = x2pnts(ReT, 41, 2, value);
  int i3 = index;
  if (index == -1) {
    printf("The value %f was not found.\n", value);
  } else {
    printf("The value %f was found at %f\n", value, index);
    printf(" the equivalent is: %f\n", ReT[i3 - 1][1]);
  }
  value = 0;
  index = x2pnts(ReT, 41, 2, value);
  int i4 = index;
  if (index == -1) {
    printf("The value %f was not found.\n", value);
  } else {
    printf("The value %f was found at %f\n", value, index);
    printf(" the equivalent is: %f\n", ReT[i4 - 1][1]);
  }
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x520,%rsp
movl   $0x0,-0x4(%rbp)
movsd  0xf36(%rip),%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  0xf21(%rip),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  0xf0c(%rip),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  0xef7(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  0xee2(%rip),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0xecd(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xeb8(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xe9b(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
movss  0xede(%rip),%xmm0
mov    $0xffffffee,%edi
call   10a0 <pow@plt>
movaps %xmm0,%xmm1
movsd  0xe71(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x498(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    $0x2,%edi
call   10a0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x498(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movss  0xe8e(%rip),%xmm0
mov    $0xfffffff8,%edi
call   10a0 <pow@plt>
movaps %xmm0,%xmm1
movsd  0xe19(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movss  0xe68(%rip),%xmm0
mov    $0xfffffff7,%edi
call   10a0 <pow@plt>
movaps %xmm0,%xmm1
movsd  0xdeb(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0xdc2(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x60(%rbp),%xmm0
divsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0xd9b(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
divsd  -0x20(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
xor    %edi,%edi
call   10a0 <pow@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  0xd5f(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0xd31(%rip),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0xd21(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0xd09(%rip),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0xce9(%rip),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0xce1(%rip),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  0xcc9(%rip),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  0xcb1(%rip),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  0xc99(%rip),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  0xc76(%rip),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  0xc5e(%rip),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movss  0xd0e(%rip),%xmm0
mov    $0xfffffffa,%edi
call   10a0 <pow@plt>
movaps %xmm0,%xmm1
movsd  0xc31(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movss  0xce5(%rip),%xmm0
mov    $0xfffffffa,%edi
call   10a0 <pow@plt>
movaps %xmm0,%xmm1
movsd  0xc00(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movss  0xcbc(%rip),%xmm0
mov    $0xfffffffd,%edi
call   10a0 <pow@plt>
movaps %xmm0,%xmm1
movsd  0xbcf(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movss  0xc93(%rip),%xmm0
mov    $0xfffffffd,%edi
call   10a0 <pow@plt>
movaps %xmm0,%xmm1
movsd  0xb9e(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  0xb82(%rip),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  0xb72(%rip),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  0xb62(%rip),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
subsd  -0x118(%rbp),%xmm0
ff
divsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x160(%rbp)
ff
lea    -0x2e0(%rbp),%rdi
xor    %esi,%esi
mov    $0x148,%edx
call   1050 <memset@plt>
movl   $0x0,-0x2e4(%rbp)
cmpl   $0x29,-0x2e4(%rbp)
jg     1521 <main+0x3a1>
mov    -0x2e4(%rbp),%eax
sub    $0x14,%eax
cvtsi2ss %eax,%xmm0
movslq -0x2e4(%rbp),%rax
movss  %xmm0,-0x2e0(%rbp,%rax,8)
ff ff
mov    -0x2e4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2e4(%rbp)
jmp    14e3 <main+0x363>
lea    -0x430(%rbp),%rdi
xor    %esi,%esi
mov    $0x148,%edx
call   1050 <memset@plt>
movl   $0x0,-0x434(%rbp)
cmpl   $0x29,-0x434(%rbp)
jg     157c <main+0x3fc>
mov    -0x434(%rbp),%eax
sub    $0x14,%eax
cvtsi2ss %eax,%xmm0
movslq -0x434(%rbp),%rax
movss  %xmm0,-0x430(%rbp,%rax,8)
ff ff
mov    -0x434(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x434(%rbp)
jmp    153e <main+0x3be>
movsd  -0xa0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     174f <main+0x5cf>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x4a0(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  0xa95(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x4a8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
call   1080 <cos@plt>
movsd  -0x4a8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x4a0(%rbp),%xmm0
ff
movss  0xb09(%rip),%xmm3
divss  %xmm3,%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x478(%rbp)
ff
fldl   -0x478(%rbp)
fstpt  -0x100(%rbp)
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     1689 <main+0x509>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x4b0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
call   1080 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x4b0(%rbp),%xmm0
ff
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  0xa16(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x488(%rbp)
ff
fldl   -0x488(%rbp)
fstpt  -0x110(%rbp)
jmp    174a <main+0x5ca>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x4d0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
call   1080 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x4d0(%rbp),%xmm0
ff
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  0x9ae(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x4c0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x4b8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   1070 <tan@plt>
movsd  %xmm0,-0x4c8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1070 <tan@plt>
movsd  -0x4c8(%rbp),%xmm2
ff
movsd  -0x4c0(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0x4b8(%rbp),%xmm0
ff
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x480(%rbp)
ff
fldl   -0x480(%rbp)
fstpt  -0x110(%rbp)
jmp    18fc <main+0x77c>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x4d8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
call   1080 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x4d8(%rbp),%xmm0
ff
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  0x8e8(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x460(%rbp)
ff
fldl   -0x460(%rbp)
fstpt  -0x110(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
call   1030 <fabsl@plt>
movaps %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     1839 <main+0x6b9>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x4e0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
call   1080 <cos@plt>
movsd  -0x4e0(%rbp),%xmm1
ff
cvtss2sd %xmm0,%xmm0
mulsd  %xmm0,%xmm1
movsd  0x8ce(%rip),%xmm0
divsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
divsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x470(%rbp)
ff
fldl   -0x470(%rbp)
fstpt  -0x100(%rbp)
jmp    18f7 <main+0x777>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x500(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
call   1080 <cos@plt>
movsd  -0x500(%rbp),%xmm1
ff
cvtss2sd %xmm0,%xmm0
mulsd  %xmm0,%xmm1
movsd  0x869(%rip),%xmm0
divsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
divsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x4e8(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x4f0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   1070 <tan@plt>
movsd  %xmm0,-0x4f8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1070 <tan@plt>
movsd  -0x4f8(%rbp),%xmm2
ff
movsd  -0x4f0(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0x4e8(%rbp),%xmm0
ff
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x468(%rbp)
ff
fldl   -0x468(%rbp)
fstpt  -0x100(%rbp)
jmp    18fc <main+0x77c>
movl   $0xffffffec,-0x438(%rbp)
ff ff ff
cmpl   $0x14,-0x438(%rbp)
jg     1b3e <main+0x9be>
fldt   -0x100(%rbp)
fstps  -0x48c(%rbp)
movss  -0x48c(%rbp),%xmm0
ff
movss  %xmm0,-0x18c(%rbp)
ff
flds   -0x18c(%rbp)
fldt   -0x110(%rbp)
fucomip %st(1),%st
fstp   %st(0)
jbe    1b25 <main+0x9a5>
jmp    194a <main+0x7ca>
movsd  0x71e(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
cvtsi2sdl -0x438(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movss  -0x18c(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x10(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x184(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x520(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    $0x2,%edi
call   10a0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x520(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  0x694(%rip),%xmm1
mulsd  -0x38(%rbp),%xmm1
mulsd  -0x30(%rbp),%xmm1
divsd  -0x28(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x508(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x510(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    $0x2,%edi
call   10a0 <pow@plt>
movsd  %xmm0,-0x518(%rbp)
ff
movss  -0x18c(%rbp),%xmm0
ff
mov    $0x2,%edi
call   10a0 <pow@plt>
movsd  -0x518(%rbp),%xmm2
ff
movsd  -0x510(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0x508(%rbp),%xmm0
ff
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
movsd  0x672(%rip),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x188(%rbp)
ff
mov    -0x438(%rbp),%eax
add    $0x14,%eax
mov    %eax,-0x190(%rbp)
movss  -0x188(%rbp),%xmm0
ff
addss  -0x184(%rbp),%xmm0
ff
call   1080 <cos@plt>
movslq -0x190(%rbp),%rax
addss  -0x2dc(%rbp,%rax,8),%xmm0
ff ff
movss  %xmm0,-0x2dc(%rbp,%rax,8)
ff ff
movss  -0x188(%rbp),%xmm0
ff
addss  -0x184(%rbp),%xmm0
ff
call   1060 <sin@plt>
cvtsi2ss %rax,%xmm0
movslq -0x190(%rbp),%rax
addss  -0x42c(%rbp,%rax,8),%xmm0
ff ff
movss  %xmm0,-0x42c(%rbp,%rax,8)
ff ff
movsd  -0x60(%rbp),%xmm1
divsd  -0x80(%rbp),%xmm1
movss  -0x18c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x18c(%rbp)
ff
jmp    192f <main+0x7af>
jmp    1b2a <main+0x9aa>
mov    -0x438(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x438(%rbp)
jmp    1906 <main+0x786>
movl   $0x0,-0x43c(%rbp)
cmpl   $0x28,-0x43c(%rbp)
jg     1bea <main+0xa6a>
movslq -0x43c(%rbp),%rax
movss  -0x2dc(%rbp,%rax,8),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
divsd  -0x80(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x43c(%rbp),%rax
movss  %xmm0,-0x2dc(%rbp,%rax,8)
ff ff
movslq -0x43c(%rbp),%rax
movss  -0x42c(%rbp,%rax,8),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
divsd  -0x80(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x43c(%rbp),%rax
movss  %xmm0,-0x42c(%rbp,%rax,8)
ff ff
movslq -0x43c(%rbp),%rax
movss  -0x2dc(%rbp,%rax,8),%xmm0
ff ff
mov    -0x43c(%rbp),%esi
sub    $0x14,%esi
lea    0x52d(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x43c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x43c(%rbp)
jmp    1b48 <main+0x9c8>
movss  0x502(%rip),%xmm0
movss  %xmm0,-0x444(%rbp)
ff
lea    -0x2e0(%rbp),%rdi
movss  -0x444(%rbp),%xmm0
ff
mov    $0x29,%esi
mov    $0x2,%edx
call   1090 <x2pnts@plt>
movss  %xmm0,-0x440(%rbp)
ff
cvttss2si -0x440(%rbp),%eax
ff
mov    %eax,-0x450(%rbp)
movss  -0x440(%rbp),%xmm0
ff
movss  0x4b2(%rip),%xmm1
ucomiss %xmm1,%xmm0
jne    1c68 <main+0xae8>
jp     1c68 <main+0xae8>
movss  -0x444(%rbp),%xmm0
ff
lea    0x4c3(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
jmp    1cac <main+0xb2c>
movss  -0x444(%rbp),%xmm0
ff
movss  -0x440(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
lea    0x4b9(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
mov    -0x450(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0x2dc(%rbp,%rax,8),%xmm0
ff ff
lea    0x4b5(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movss  0x444(%rip),%xmm0
movss  %xmm0,-0x444(%rbp)
ff
lea    -0x2e0(%rbp),%rdi
movss  -0x444(%rbp),%xmm0
ff
mov    $0x29,%esi
mov    $0x2,%edx
call   1090 <x2pnts@plt>
movss  %xmm0,-0x440(%rbp)
ff
cvttss2si -0x440(%rbp),%eax
ff
mov    %eax,-0x454(%rbp)
movss  -0x440(%rbp),%xmm0
ff
movss  0x3f0(%rip),%xmm1
ucomiss %xmm1,%xmm0
jne    1d2a <main+0xbaa>
jp     1d2a <main+0xbaa>
movss  -0x444(%rbp),%xmm0
ff
lea    0x401(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
jmp    1d6e <main+0xbee>
movss  -0x444(%rbp),%xmm0
ff
movss  -0x440(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
lea    0x3f7(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
mov    -0x454(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0x2dc(%rbp,%rax,8),%xmm0
ff ff
lea    0x3f3(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x444(%rbp)
ff
lea    -0x2e0(%rbp),%rdi
movss  -0x444(%rbp),%xmm0
ff
mov    $0x29,%esi
mov    $0x2,%edx
call   1090 <x2pnts@plt>
movss  %xmm0,-0x440(%rbp)
ff
cvttss2si -0x440(%rbp),%eax
ff
mov    %eax,-0x458(%rbp)
movss  -0x440(%rbp),%xmm0
ff
movss  0x333(%rip),%xmm1
ucomiss %xmm1,%xmm0
jne    1de7 <main+0xc67>
jp     1de7 <main+0xc67>
movss  -0x444(%rbp),%xmm0
ff
lea    0x344(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
jmp    1e2b <main+0xcab>
movss  -0x444(%rbp),%xmm0
ff
movss  -0x440(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
lea    0x33a(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
mov    -0x458(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0x2dc(%rbp,%rax,8),%xmm0
ff ff
lea    0x336(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x520,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r14
push   %rbx
sub    $0x318,%rsp
movss  0xe8e(%rip),%xmm0
mov    $0xffffffee,%edi
call   1080 <pow@plt>
mulsd  0xe9c(%rip),%xmm0
movsd  %xmm0,0x10(%rsp)
movss  0xe72(%rip),%xmm0
mov    $0x2,%edi
call   1080 <pow@plt>
movsd  0x10(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
movss  0xe4c(%rip),%xmm0
mov    $0xfffffff8,%edi
call   1080 <pow@plt>
movsd  %xmm0,0x8(%rsp)
movss  0xe34(%rip),%xmm0
mov    $0xfffffff7,%edi
call   1080 <pow@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x10(%rsp),%xmm0
addsd  %xmm0,%xmm0
mulsd  0xe3a(%rip),%xmm0
divsd  0xe3a(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
xor    %edi,%edi
call   1080 <pow@plt>
movsd  %xmm0,0x48(%rsp)
movss  0xdf1(%rip),%xmm0
mov    $0xfffffffa,%edi
call   1080 <pow@plt>
movss  0xddf(%rip),%xmm0
mov    $0xfffffffa,%edi
call   1080 <pow@plt>
movss  0xdcd(%rip),%xmm0
mov    $0xfffffffd,%edi
call   1080 <pow@plt>
movss  0xdbb(%rip),%xmm0
mov    $0xfffffffd,%edi
call   1080 <pow@plt>
lea    0x80(%rsp),%rdi
mov    $0x148,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movl   $0xc1a00000,0x80(%rsp)
movl   $0xc1980000,0x88(%rsp)
movl   $0xc1900000,0x90(%rsp)
movl   $0xc1880000,0x98(%rsp)
movl   $0xc1800000,0xa0(%rsp)
movl   $0xc1700000,0xa8(%rsp)
movl   $0xc1600000,0xb0(%rsp)
movl   $0xc1500000,0xb8(%rsp)
movl   $0xc1400000,0xc0(%rsp)
movl   $0xc1300000,0xc8(%rsp)
movl   $0xc1200000,0xd0(%rsp)
movl   $0xc1100000,0xd8(%rsp)
movl   $0xc1000000,0xe0(%rsp)
movl   $0xc0e00000,0xe8(%rsp)
movl   $0xc0c00000,0xf0(%rsp)
movl   $0xc0a00000,0xf8(%rsp)
movl   $0xc0800000,0x100(%rsp)
movl   $0xc0400000,0x108(%rsp)
movl   $0xc0000000,0x110(%rsp)
movl   $0xbf800000,0x118(%rsp)
movl   $0x0,0x120(%rsp)
movl   $0x3f800000,0x128(%rsp)
movl   $0x40000000,0x130(%rsp)
movl   $0x40400000,0x138(%rsp)
movl   $0x40800000,0x140(%rsp)
movl   $0x40a00000,0x148(%rsp)
movl   $0x40c00000,0x150(%rsp)
movl   $0x40e00000,0x158(%rsp)
movl   $0x41000000,0x160(%rsp)
movl   $0x41100000,0x168(%rsp)
movl   $0x41200000,0x170(%rsp)
movl   $0x41300000,0x178(%rsp)
movl   $0x41400000,0x180(%rsp)
movl   $0x41500000,0x188(%rsp)
movl   $0x41600000,0x190(%rsp)
movl   $0x41700000,0x198(%rsp)
movl   $0x41800000,0x1a0(%rsp)
movl   $0x41880000,0x1a8(%rsp)
movl   $0x41900000,0x1b0(%rsp)
movl   $0x41980000,0x1b8(%rsp)
movl   $0x41a00000,0x1c0(%rsp)
movl   $0x41a80000,0x1c8(%rsp)
movsd  0x8(%rsp),%xmm0
mulsd  0xbf9(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
lea    0x1d0(%rsp),%rdi
mov    $0x148,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movl   $0xc1a00000,0x1d0(%rsp)
movl   $0xc1980000,0x1d8(%rsp)
movl   $0xc1900000,0x1e0(%rsp)
movl   $0xc1880000,0x1e8(%rsp)
movl   $0xc1800000,0x1f0(%rsp)
movl   $0xc1700000,0x1f8(%rsp)
movl   $0xc1600000,0x200(%rsp)
movl   $0xc1500000,0x208(%rsp)
movl   $0xc1400000,0x210(%rsp)
movl   $0xc1300000,0x218(%rsp)
movl   $0xc1200000,0x220(%rsp)
movl   $0xc1100000,0x228(%rsp)
movl   $0xc1000000,0x230(%rsp)
movl   $0xc0e00000,0x238(%rsp)
movl   $0xc0c00000,0x240(%rsp)
movl   $0xc0a00000,0x248(%rsp)
movl   $0xc0800000,0x250(%rsp)
movl   $0xc0400000,0x258(%rsp)
movl   $0xc0000000,0x260(%rsp)
movl   $0xbf800000,0x268(%rsp)
movl   $0x0,0x270(%rsp)
movl   $0x3f800000,0x278(%rsp)
movl   $0x40000000,0x280(%rsp)
movl   $0x40400000,0x288(%rsp)
movl   $0x40800000,0x290(%rsp)
movl   $0x40a00000,0x298(%rsp)
movl   $0x40c00000,0x2a0(%rsp)
movl   $0x40e00000,0x2a8(%rsp)
movl   $0x41000000,0x2b0(%rsp)
movl   $0x41100000,0x2b8(%rsp)
movl   $0x41200000,0x2c0(%rsp)
movl   $0x41300000,0x2c8(%rsp)
movl   $0x41400000,0x2d0(%rsp)
movl   $0x41500000,0x2d8(%rsp)
movl   $0x41600000,0x2e0(%rsp)
movl   $0x41700000,0x2e8(%rsp)
movl   $0x41800000,0x2f0(%rsp)
movl   $0x41880000,0x2f8(%rsp)
movl   $0x41900000,0x300(%rsp)
movl   $0x41980000,0x308(%rsp)
movl   $0x41a00000,0x310(%rsp)
movl   $0x41a80000,0x318(%rsp)
movsd  0x20(%rsp),%xmm3
mulsd  0xa0b(%rip),%xmm3
movsd  0xa0b(%rip),%xmm0
movsd  0x8(%rsp),%xmm2
mulsd  %xmm2,%xmm0
movsd  0xa01(%rip),%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm2,%xmm4
divsd  0x9f9(%rip),%xmm4
subsd  %xmm4,%xmm1
movsd  %xmm1,0x68(%rsp)
fldl   0x68(%rsp)
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x2c(%rsp)
movss  %xmm0,0x3c(%rsp)
flds   0x3c(%rsp)
fstpt  0x74(%rsp)
movapd %xmm3,%xmm0
mulsd  %xmm2,%xmm0
mulsd  0x9cb(%rip),%xmm0
movsd  %xmm0,0x20(%rsp)
xorps  %xmm0,%xmm0
cvtsd2ss %xmm2,%xmm0
movss  %xmm0,0x30(%rsp)
mov    $0xffffffffffffffec,%rbx
movsd  0x9b9(%rip),%xmm1
movss  0x949(%rip),%xmm0
movsd  %xmm4,0x40(%rsp)
fld    %st(0)
fstpt  0x10(%rsp)
jmp    16de <main+0x57e>
nopl   (%rax)
add    $0x1,%rbx
cmp    $0x15,%rbx
je     1834 <main+0x6d4>
fldt   0x74(%rsp)
fxch   %st(1)
fucomi %st(1),%st
fstp   %st(1)
jbe    16d0 <main+0x570>
fstp   %st(0)
xorps  %xmm2,%xmm2
cvtsi2sd %ebx,%xmm2
mulsd  0x96d(%rip),%xmm2
movsd  %xmm2,0x50(%rsp)
movss  0x2c(%rsp),%xmm3
fldz
nopl   0x0(%rax)
fstp   %st(0)
movss  %xmm3,0x34(%rsp)
cvtss2sd %xmm3,%xmm3
movsd  %xmm3,0x8(%rsp)
movsd  0x50(%rsp),%xmm2
mulsd  %xmm3,%xmm2
divsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
movss  %xmm1,0x4(%rsp)
mov    $0x2,%edi
call   1080 <pow@plt>
mulsd  0x20(%rsp),%xmm0
mulsd  0x923(%rip),%xmm0
movsd  %xmm0,0x60(%rsp)
movss  0x30(%rsp),%xmm0
mov    $0x2,%edi
call   1080 <pow@plt>
movsd  %xmm0,0x58(%rsp)
movss  0x34(%rsp),%xmm0
mov    $0x2,%edi
call   1080 <pow@plt>
movsd  0x58(%rsp),%xmm1
mulsd  0x8f1(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x48(%rsp),%xmm1
movsd  0x60(%rsp),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
addss  0x4(%rsp),%xmm0
movss  %xmm0,0x4(%rsp)
call   1060 <cos@plt>
addss  0x124(%rsp,%rbx,8),%xmm0
movss  %xmm0,0x124(%rsp,%rbx,8)
movss  0x4(%rsp),%xmm0
call   1050 <sin@plt>
movss  0x82b(%rip),%xmm0
movsd  0x88b(%rip),%xmm1
movsd  0x40(%rsp),%xmm4
xorps  %xmm2,%xmm2
cvtsi2ss %rax,%xmm2
addss  0x274(%rsp,%rbx,8),%xmm2
movsd  0x8(%rsp),%xmm3
addsd  %xmm4,%xmm3
cvtsd2ss %xmm3,%xmm3
movss  %xmm2,0x274(%rsp,%rbx,8)
movss  %xmm3,0x38(%rsp)
flds   0x38(%rsp)
fldt   0x10(%rsp)
fucomip %st(1),%st
fstp   %st(0)
fldt   0x10(%rsp)
ja     1710 <main+0x5b0>
jmp    16d0 <main+0x570>
fstp   %st(0)
xor    %ebx,%ebx
lea    0x849(%rip),%r14
nop
movss  0x84(%rsp,%rbx,8),%xmm0
movss  0x7bb(%rip),%xmm2
divss  %xmm2,%xmm0
movss  %xmm0,0x84(%rsp,%rbx,8)
movss  0x1d4(%rsp,%rbx,8),%xmm1
divss  %xmm2,%xmm1
movss  %xmm1,0x1d4(%rsp,%rbx,8)
lea    -0x14(%rbx),%esi
mov    %r14,%rdi
mov    $0x1,%al
call   1030 <printf@plt>
add    $0x1,%rbx
cmp    $0x29,%rbx
jne    1840 <main+0x6e0>
lea    0x80(%rsp),%rdi
movss  0x775(%rip),%xmm0
mov    $0x29,%esi
mov    $0x2,%edx
call   1070 <x2pnts@plt>
ucomiss 0x763(%rip),%xmm0
jne    18c6 <main+0x766>
jp     18c6 <main+0x766>
lea    0x7ef(%rip),%rdi
movss  0x74c(%rip),%xmm0
jmp    18f7 <main+0x797>
cvttss2si %xmm0,%ebx
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
lea    0x7f0(%rip),%rdi
movss  0x730(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movslq %ebx,%rax
movss  0x7c(%rsp,%rax,8),%xmm0
lea    0x7ef(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0x80(%rsp),%rdi
movss  0x70a(%rip),%xmm0
mov    $0x29,%esi
mov    $0x2,%edx
call   1070 <x2pnts@plt>
ucomiss 0x6f0(%rip),%xmm0
jne    1939 <main+0x7d9>
jp     1939 <main+0x7d9>
lea    0x77c(%rip),%rdi
movss  0x6e1(%rip),%xmm0
jmp    196a <main+0x80a>
cvttss2si %xmm0,%ebx
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
lea    0x77d(%rip),%rdi
movss  0x6c5(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movslq %ebx,%rax
movss  0x7c(%rsp,%rax,8),%xmm0
lea    0x77c(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0x80(%rsp),%rdi
xorps  %xmm0,%xmm0
mov    $0x29,%esi
mov    $0x2,%edx
call   1070 <x2pnts@plt>
ucomiss 0x682(%rip),%xmm0
jne    19a2 <main+0x842>
jp     19a2 <main+0x842>
lea    0x70e(%rip),%rdi
xorps  %xmm0,%xmm0
jmp    19ce <main+0x86e>
cvttss2si %xmm0,%ebx
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
lea    0x714(%rip),%rdi
xorps  %xmm0,%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movslq %ebx,%rax
movss  0x7c(%rsp,%rax,8),%xmm0
lea    0x718(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x318,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
@.str = [35 x i8] c"value of ReT is: %f and j is: %d \0A\00"
@.str.1 = [29 x i8] c"The value %f was not found.\0A\00"
@.str.2 = [30 x i8] c"The value %f was found at %f\0A\00"
@.str.3 = [24 x i8] c" the equivalent is: %f\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca double
%3 = alloca double
%4 = alloca double
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca double
%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
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca x86_fp80
%31 = alloca x86_fp80
%32 = alloca double
%33 = alloca double
%34 = alloca double
%35 = alloca double
%36 = alloca double
%37 = alloca double
%38 = alloca double
%39 = alloca double
%40 = alloca double
%41 = alloca double
%42 = alloca double
%43 = alloca double
%44 = alloca double
%45 = alloca double
%46 = alloca float
%47 = alloca float
%48 = alloca float
%49 = alloca i32
%50 = alloca [41 x [2 x float]]
%51 = alloca i32
%52 = alloca [41 x [2 x float]]
%53 = alloca i32
%54 = alloca i32
%55 = alloca i32
%56 = alloca float
%57 = alloca float
%58 = alloca i32
%59 = alloca i32
%60 = alloca i32
%61 = alloca i32
%62 = alloca i32
store i32 0, i32* %1
store double 0x3E7AD7F29ABCAF48, double* %2
store double 0x3C07A4DA07DED404, double* %3
store double 0x39B279DC8B6970AD, double* %4
store double 0x390B860B482CE8F1, double* %5
store double 0x3E434CF57723AB8B, double* %6
store double 0x400921FB54442D11, double* %7
store double 0x4005BF0A8B145774, double* %8
store double 0.000000e+00, double* %9
store double 0x3DA5FD7FE1796495, double* %10
%63 = call double @pow(float 1.000000e+01, i32 -18)
%64 = fmul double 1.500000e+00, %63
%65 = load double, double* %10
%66 = fptrunc double %65 to float
%67 = call double @pow(float %66, i32 2)
%68 = fdiv double %64, %67
store double %68, double* %11
%69 = call double @pow(float 1.000000e+01, i32 -8)
%70 = fmul double 4.000000e+00, %69
store double %70, double* %12
%71 = call double @pow(float 1.000000e+01, i32 -9)
%72 = fmul double 1.400000e+01, %71
store double %72, double* %13
store double 0.000000e+00, double* %14
store double 0.000000e+00, double* %15
store double 1.000000e+03, double* %16
%73 = load double, double* %12
%74 = load double, double* %2
%75 = fdiv double %73, %74
store double %75, double* %17
%76 = load double, double* %11
%77 = fmul double 2.000000e+00, %76
%78 = load double, double* %3
%79 = fmul double %77, %78
%80 = load double, double* %4
%81 = fdiv double %79, %80
%82 = fptrunc double %81 to float
%83 = call double @pow(float %82, i32 0)
store double %83, double* %18
%84 = load double, double* %14
%85 = load double, double* %7
%86 = fmul double %84, %85
%87 = fdiv double %86, 1.800000e+02
store double %87, double* %19
%88 = load double, double* %15
%89 = load double, double* %7
%90 = fmul double %88, %89
store double %90, double* %20
store double 4.000000e-01, double* %21
store double 4.000000e-01, double* %22
store double -4.040000e+00, double* %23
store double 0x3EB0C6F7A0B5ED8D, double* %24
store double 3.000000e-05, double* %25
store double 0x3EB0C6F7A0B5ED8D, double* %26
store double 1.000000e+00, double* %27
store double 5.000000e-08, double* %28
store double 0.000000e+00, double* %29
store double -1.000000e-01, double* %32
store double 2.100000e+00, double* %33
%91 = call double @pow(float 1.000000e+01, i32 -6)
%92 = fmul double -2.000000e+02, %91
store double %92, double* %34
%93 = call double @pow(float 1.000000e+01, i32 -6)
%94 = fmul double 2.000000e+02, %93
store double %94, double* %35
%95 = call double @pow(float 1.000000e+01, i32 -3)
%96 = fmul double -1.100000e-01, %95
store double %96, double* %36
%97 = call double @pow(float 1.000000e+01, i32 -3)
%98 = fmul double 1.100000e-01, %97
store double %98, double* %37
store double 3.000000e+02, double* %38
store double 3.000000e+02, double* %39
store double 3.000000e+02, double* %40
%99 = load double, double* %33
%100 = load double, double* %32
%101 = fsub double %99, %100
%102 = load double, double* %40
%103 = fdiv double %101, %102
store double %103, double* %41
%104 = bitcast [41 x [2 x float]]* %50 to i8*
store i32 0, i32* %51
br label %105
105: ; preds = %116, %0
%106 = load i32, i32* %51
%107 = icmp sle i32 %106, 41
br i1 %107, label %108, label %119
108: ; preds = %105
%109 = load i32, i32* %51
%110 = sub nsw i32 %109, 20
%111 = sitofp i32 %110 to float
%112 = load i32, i32* %51
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %50, i64 0, i64 %113
%115 = getelementptr inbounds [2 x float], [2 x float]* %114, i64 0, i64 0
store float %111, float* %115
br label %116
116: ; preds = %108
%117 = load i32, i32* %51
%118 = add nsw i32 %117, 1
store i32 %118, i32* %51
br label %105
119: ; preds = %105
%120 = bitcast [41 x [2 x float]]* %52 to i8*
store i32 0, i32* %53
br label %121
121: ; preds = %132, %119
%122 = load i32, i32* %53
%123 = icmp sle i32 %122, 41
br i1 %123, label %124, label %135
124: ; preds = %121
%125 = load i32, i32* %53
%126 = sub nsw i32 %125, 20
%127 = sitofp i32 %126 to float
%128 = load i32, i32* %53
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %52, i64 0, i64 %129
%131 = getelementptr inbounds [2 x float], [2 x float]* %130, i64 0, i64 0
store float %127, float* %131
br label %132
132: ; preds = %124
%133 = load i32, i32* %53
%134 = add nsw i32 %133, 1
store i32 %134, i32* %53
br label %121
135: ; preds = %121
%136 = load double, double* %20
%137 = fcmp oge double %136, 0.000000e+00
br i1 %137, label %138, label %187
138: ; preds = %135
%139 = load double, double* %12
%140 = load double, double* %16
%141 = fdiv double 1.000000e+00, %140
%142 = load double, double* %20
%143 = fptrunc double %142 to float
%144 = call float @cos(float %143)
%145 = fdiv float %144, 2.000000e+00
%146 = fpext float %145 to double
%147 = fsub double %141, %146
%148 = fmul double %139, %147
%149 = fpext double %148 to x86_fp80
store x86_fp80 %149, x86_fp80* %30
%150 = load double, double* %20
%151 = load double, double* %19
%152 = fcmp ole double %150, %151
br i1 %152, label %153, label %166
153: ; preds = %138
%154 = load double, double* %12
%155 = load double, double* %20
%156 = fptrunc double %155 to float
%157 = call float @cos(float %156)
%158 = fpext float %157 to double
%159 = fmul double %154, %158
%160 = fdiv double %159, 2.000000e+00
%161 = load double, double* %12
%162 = load double, double* %16
%163 = fdiv double %161, %162
%164 = fsub double %160, %163
%165 = fpext double %164 to x86_fp80
store x86_fp80 %165, x86_fp80* %31
br label %186
166: ; preds = %138
%167 = load double, double* %12
%168 = load double, double* %20
%169 = fptrunc double %168 to float
%170 = call float @cos(float %169)
%171 = fpext float %170 to double
%172 = fmul double %167, %171
%173 = fdiv double %172, 2.000000e+00
%174 = load double, double* %12
%175 = load double, double* %16
%176 = fdiv double %174, %175
%177 = fsub double %173, %176
%178 = load double, double* %13
%179 = load double, double* %19
%180 = call double @tan(double %179)
%181 = load double, double* %20
%182 = call double @tan(double %181)
%183 = fsub double %180, %182
%184 = call double @llvm.fmuladd.f64(double %178, double %183, double %177)
%185 = fpext double %184 to x86_fp80
store x86_fp80 %185, x86_fp80* %31
br label %186
186: ; preds = %166, %153
br label %241
187: ; preds = %135
%188 = load double, double* %12
%189 = load double, double* %20
%190 = fptrunc double %189 to float
%191 = call float @cos(float %190)
%192 = fpext float %191 to double
%193 = fmul double %188, %192
%194 = fdiv double %193, 2.000000e+00
%195 = load double, double* %12
%196 = load double, double* %16
%197 = fdiv double %195, %196
%198 = fsub double %194, %197
%199 = fpext double %198 to x86_fp80
store x86_fp80 %199, x86_fp80* %31
%200 = load double, double* %20
%201 = call double @fabsl(double %200)
%202 = load double, double* %19
%203 = fcmp ole double %201, %202
br i1 %203, label %204, label %218
204: ; preds = %187
%205 = load double, double* %12
%206 = load double, double* %20
%207 = fptrunc double %206 to float
%208 = call float @cos(float %207)
%209 = fpext float %208 to double
%210 = fmul double %205, %209
%211 = fdiv double %210, 2.000000e+00
%212 = fneg double %211
%213 = load double, double* %12
%214 = load double, double* %16
%215 = fdiv double %213, %214
%216 = fadd double %212, %215
%217 = fpext double %216 to x86_fp80
store x86_fp80 %217, x86_fp80* %30
br label %240
218: ; preds = %187
%219 = load double, double* %12
%220 = load double, double* %20
%221 = fptrunc double %220 to float
%222 = call float @cos(float %221)
%223 = fpext float %222 to double
%224 = fmul double %219, %223
%225 = fdiv double %224, 2.000000e+00
%226 = fneg double %225
%227 = load double, double* %12
%228 = load double, double* %16
%229 = fdiv double %227, %228
%230 = fadd double %226, %229
%231 = load double, double* %13
%232 = load double, double* %19
%233 = call double @tan(double %232)
%234 = load double, double* %20
%235 = call double @tan(double %234)
%236 = fsub double %233, %235
%237 = fneg double %231
%238 = call double @llvm.fmuladd.f64(double %237, double %236, double %230)
%239 = fpext double %238 to x86_fp80
store x86_fp80 %239, x86_fp80* %30
br label %240
240: ; preds = %218, %204
br label %241
241: ; preds = %240, %186
store i32 -20, i32* %54
br label %242
242: ; preds = %325, %241
%243 = load i32, i32* %54
%244 = icmp sle i32 %243, 20
br i1 %244, label %245, label %328
245: ; preds = %242
%246 = load x86_fp80, x86_fp80* %30
%247 = fptrunc x86_fp80 %246 to float
store float %247, float* %48
br label %248
248: ; preds = %316, %245
%249 = load float, float* %48
%250 = fpext float %249 to x86_fp80
%251 = load x86_fp80, x86_fp80* %31
%252 = fcmp olt x86_fp80 %250, %251
br i1 %252, label %253, label %324
253: ; preds = %248
%254 = load double, double* %7
%255 = fmul double 2.000000e+00, %254
%256 = load i32, i32* %54
%257 = sitofp i32 %256 to double
%258 = fmul double %255, %257
%259 = load float, float* %48
%260 = fpext float %259 to double
%261 = fmul double %258, %260
%262 = load double, double* %2
%263 = fdiv double %261, %262
%264 = fptrunc double %263 to float
store float %264, float* %46
%265 = load double, double* %12
%266 = fneg double %265
%267 = load double, double* %13
%268 = fmul double %266, %267
%269 = load double, double* %9
%270 = fmul double %268, %269
%271 = load double, double* %3
%272 = fptrunc double %271 to float
%273 = call double @pow(float %272, i32 2)
%274 = fmul double %270, %273
%275 = load double, double* %7
%276 = fmul double 2.000000e+00, %275
%277 = load double, double* %6
%278 = fmul double %276, %277
%279 = load double, double* %5
%280 = fdiv double %278, %279
%281 = fmul double %274, %280
%282 = load double, double* %18
%283 = load double, double* %12
%284 = fptrunc double %283 to float
%285 = call double @pow(float %284, i32 2)
%286 = load float, float* %48
%287 = call double @pow(float %286, i32 2)
%288 = fneg double %287
%289 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %285, double %288)
%290 = fmul double %282, %289
%291 = fdiv double %281, %290
%292 = fptrunc double %291 to float
store float %292, float* %47
%293 = load i32, i32* %54
%294 = add nsw i32 %293, 20
store i32 %294, i32* %49
%295 = load float, float* %47
%296 = load float, float* %46
%297 = fadd float %295, %296
%298 = call float @cos(float %297)
%299 = load i32, i32* %49
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %50, i64 0, i64 %300
%302 = getelementptr inbounds [2 x float], [2 x float]* %301, i64 0, i64 1
%303 = load float, float* %302
%304 = fadd float %303, %298
store float %304, float* %302
%305 = load float, float* %47
%306 = load float, float* %46
%307 = fadd float %305, %306
%308 = call i64 @sin(float %307)
%309 = sitofp i64 %308 to float
%310 = load i32, i32* %49
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %52, i64 0, i64 %311
%313 = getelementptr inbounds [2 x float], [2 x float]* %312, i64 0, i64 1
%314 = load float, float* %313
%315 = fadd float %314, %309
store float %315, float* %313
br label %316
316: ; preds = %253
%317 = load double, double* %12
%318 = load double, double* %16
%319 = fdiv double %317, %318
%320 = load float, float* %48
%321 = fpext float %320 to double
%322 = fadd double %321, %319
%323 = fptrunc double %322 to float
store float %323, float* %48
br label %248
324: ; preds = %248
br label %325
325: ; preds = %324
%326 = load i32, i32* %54
%327 = add nsw i32 %326, 1
store i32 %327, i32* %54
br label %242
328: ; preds = %242
store i32 0, i32* %55
br label %329
329: ; preds = %367, %328
%330 = load i32, i32* %55
%331 = icmp sle i32 %330, 40
br i1 %331, label %332, label %370
332: ; preds = %329
%333 = load i32, i32* %55
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %50, i64 0, i64 %334
%336 = getelementptr inbounds [2 x float], [2 x float]* %335, i64 0, i64 1
%337 = load float, float* %336
%338 = fpext float %337 to double
%339 = load double, double* %16
%340 = fdiv double %338, %339
%341 = fptrunc double %340 to float
%342 = load i32, i32* %55
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %50, i64 0, i64 %343
%345 = getelementptr inbounds [2 x float], [2 x float]* %344, i64 0, i64 1
store float %341, float* %345
%346 = load i32, i32* %55
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %52, i64 0, i64 %347
%349 = getelementptr inbounds [2 x float], [2 x float]* %348, i64 0, i64 1
%350 = load float, float* %349
%351 = fpext float %350 to double
%352 = load double, double* %16
%353 = fdiv double %351, %352
%354 = fptrunc double %353 to float
%355 = load i32, i32* %55
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %52, i64 0, i64 %356
%358 = getelementptr inbounds [2 x float], [2 x float]* %357, i64 0, i64 1
store float %354, float* %358
%359 = load i32, i32* %55
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %50, i64 0, i64 %360
%362 = getelementptr inbounds [2 x float], [2 x float]* %361, i64 0, i64 1
%363 = load float, float* %362
%364 = load i32, i32* %55
%365 = sub nsw i32 %364, 20
%366 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str, i64 0, i64 0), float %363, i32 %365)
br label %367
367: ; preds = %332
%368 = load i32, i32* %55
%369 = add nsw i32 %368, 1
store i32 %369, i32* %55
br label %329
370: ; preds = %329
store float -1.600000e+01, float* %57
%371 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %50, i64 0, i64 0
%372 = bitcast [2 x float]* %371 to float**
%373 = load float, float* %57
%374 = call float @x2pnts(float** %372, i32 41, i32 2, float %373)
store float %374, float* %56
%375 = load float, float* %56
%376 = fptosi float %375 to i32
store i32 %376, i32* %60
%377 = load float, float* %56
%378 = fcmp oeq float %377, -1.000000e+00
br i1 %378, label %379, label %382
379: ; preds = %370
%380 = load float, float* %57
%381 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.1, i64 0, i64 0), float %380)
br label %394
382: ; preds = %370
%383 = load float, float* %57
%384 = load float, float* %56
%385 = fpext float %384 to double
%386 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.2, i64 0, i64 0), float %383, double %385)
%387 = load i32, i32* %60
%388 = sub nsw i32 %387, 1
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %50, i64 0, i64 %389
%391 = getelementptr inbounds [2 x float], [2 x float]* %390, i64 0, i64 1
%392 = load float, float* %391
%393 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), float %392)
br label %394
394: ; preds = %382, %379
store float 1.300000e+01, float* %57
%395 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %50, i64 0, i64 0
%396 = bitcast [2 x float]* %395 to float**
%397 = load float, float* %57
%398 = call float @x2pnts(float** %396, i32 41, i32 2, float %397)
store float %398, float* %56
%399 = load float, float* %56
%400 = fptosi float %399 to i32
store i32 %400, i32* %61
%401 = load float, float* %56
%402 = fcmp oeq float %401, -1.000000e+00
br i1 %402, label %403, label %406
403: ; preds = %394
%404 = load float, float* %57
%405 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.1, i64 0, i64 0), float %404)
br label %418
406: ; preds = %394
%407 = load float, float* %57
%408 = load float, float* %56
%409 = fpext float %408 to double
%410 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.2, i64 0, i64 0), float %407, double %409)
%411 = load i32, i32* %61
%412 = sub nsw i32 %411, 1
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %50, i64 0, i64 %413
%415 = getelementptr inbounds [2 x float], [2 x float]* %414, i64 0, i64 1
%416 = load float, float* %415
%417 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), float %416)
br label %418
418: ; preds = %406, %403
store float 0.000000e+00, float* %57
%419 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %50, i64 0, i64 0
%420 = bitcast [2 x float]* %419 to float**
%421 = load float, float* %57
%422 = call float @x2pnts(float** %420, i32 41, i32 2, float %421)
store float %422, float* %56
%423 = load float, float* %56
%424 = fptosi float %423 to i32
store i32 %424, i32* %62
%425 = load float, float* %56
%426 = fcmp oeq float %425, -1.000000e+00
br i1 %426, label %427, label %430
427: ; preds = %418
%428 = load float, float* %57
%429 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.1, i64 0, i64 0), float %428)
br label %442
430: ; preds = %418
%431 = load float, float* %57
%432 = load float, float* %56
%433 = fpext float %432 to double
%434 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.2, i64 0, i64 0), float %431, double %433)
%435 = load i32, i32* %62
%436 = sub nsw i32 %435, 1
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %50, i64 0, i64 %437
%439 = getelementptr inbounds [2 x float], [2 x float]* %438, i64 0, i64 1
%440 = load float, float* %439
%441 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), float %440)
br label %442
442: ; preds = %430, %427
%443 = load i32, i32* %1
ret i32 %443
}

LLVM IR (-O2):
@.str = [35 x i8] c"value of ReT is: %f and j is: %d \0A\00"
@.str.1 = [29 x i8] c"The value %f was not found.\0A\00"
@.str.2 = [30 x i8] c"The value %f was found at %f\0A\00"
@.str.3 = [24 x i8] c" the equivalent is: %f\0A\00"
define i32 @main() {
%1 = alloca [41 x [2 x float]]
%2 = alloca [41 x [2 x float]]
%3 = tail call double @pow(float 1.000000e+01, i32 -18)
%4 = fmul double %3, 1.500000e+00
%5 = tail call double @pow(float 0x3DA5FD7FE0000000, i32 2)
%6 = fdiv double %4, %5
%7 = tail call double @pow(float 1.000000e+01, i32 -8)
%8 = tail call double @pow(float 1.000000e+01, i32 -9)
%9 = fmul double %6, 2.000000e+00
%10 = fmul double %9, 0x3C07A4DA07DED404
%11 = fdiv double %10, 0x39B279DC8B6970AD
%12 = fptrunc double %11 to float
%13 = tail call double @pow(float %12, i32 0)
%14 = tail call double @pow(float 1.000000e+01, i32 -6)
%15 = tail call double @pow(float 1.000000e+01, i32 -6)
%16 = tail call double @pow(float 1.000000e+01, i32 -3)
%17 = tail call double @pow(float 1.000000e+01, i32 -3)
%18 = bitcast [41 x [2 x float]]* %1 to i8*
%19 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 0, i64 0
%20 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 1, i64 0
%21 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 2, i64 0
%22 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 3, i64 0
store float -2.000000e+01, float* %19
store float -1.900000e+01, float* %20
store float -1.800000e+01, float* %21
store float -1.700000e+01, float* %22
%23 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 4, i64 0
%24 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 5, i64 0
%25 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 6, i64 0
%26 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 7, i64 0
store float -1.600000e+01, float* %23
store float -1.500000e+01, float* %24
store float -1.400000e+01, float* %25
store float -1.300000e+01, float* %26
%27 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 8, i64 0
%28 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 9, i64 0
%29 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 10, i64 0
%30 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 11, i64 0
store float -1.200000e+01, float* %27
store float -1.100000e+01, float* %28
store float -1.000000e+01, float* %29
store float -9.000000e+00, float* %30
%31 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 12, i64 0
%32 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 13, i64 0
%33 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 14, i64 0
%34 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 15, i64 0
store float -8.000000e+00, float* %31
store float -7.000000e+00, float* %32
store float -6.000000e+00, float* %33
store float -5.000000e+00, float* %34
%35 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 16, i64 0
%36 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 17, i64 0
%37 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 18, i64 0
%38 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 19, i64 0
store float -4.000000e+00, float* %35
store float -3.000000e+00, float* %36
store float -2.000000e+00, float* %37
store float -1.000000e+00, float* %38
%39 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 20, i64 0
%40 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 21, i64 0
%41 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 22, i64 0
%42 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 23, i64 0
store float 0.000000e+00, float* %39
store float 1.000000e+00, float* %40
store float 2.000000e+00, float* %41
store float 3.000000e+00, float* %42
%43 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 24, i64 0
%44 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 25, i64 0
%45 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 26, i64 0
%46 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 27, i64 0
store float 4.000000e+00, float* %43
store float 5.000000e+00, float* %44
store float 6.000000e+00, float* %45
store float 7.000000e+00, float* %46
%47 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 28, i64 0
%48 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 29, i64 0
%49 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 30, i64 0
%50 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 31, i64 0
store float 8.000000e+00, float* %47
store float 9.000000e+00, float* %48
store float 1.000000e+01, float* %49
store float 1.100000e+01, float* %50
%51 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 32, i64 0
%52 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 33, i64 0
%53 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 34, i64 0
%54 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 35, i64 0
store float 1.200000e+01, float* %51
store float 1.300000e+01, float* %52
store float 1.400000e+01, float* %53
store float 1.500000e+01, float* %54
%55 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 36, i64 0
%56 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 37, i64 0
%57 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 38, i64 0
%58 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 39, i64 0
store float 1.600000e+01, float* %55
store float 1.700000e+01, float* %56
store float 1.800000e+01, float* %57
store float 1.900000e+01, float* %58
%59 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 40, i64 0
store float 2.000000e+01, float* %59
%60 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 41, i64 0
store float 2.100000e+01, float* %60
%61 = fmul double %7, 4.000000e+00
%62 = bitcast [41 x [2 x float]]* %2 to i8*
%63 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 0, i64 0
%64 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 1, i64 0
%65 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 2, i64 0
%66 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 3, i64 0
store float -2.000000e+01, float* %63
store float -1.900000e+01, float* %64
store float -1.800000e+01, float* %65
store float -1.700000e+01, float* %66
%67 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 4, i64 0
%68 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 5, i64 0
%69 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 6, i64 0
%70 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 7, i64 0
store float -1.600000e+01, float* %67
store float -1.500000e+01, float* %68
store float -1.400000e+01, float* %69
store float -1.300000e+01, float* %70
%71 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 8, i64 0
%72 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 9, i64 0
%73 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 10, i64 0
%74 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 11, i64 0
store float -1.200000e+01, float* %71
store float -1.100000e+01, float* %72
store float -1.000000e+01, float* %73
store float -9.000000e+00, float* %74
%75 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 12, i64 0
%76 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 13, i64 0
%77 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 14, i64 0
%78 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 15, i64 0
store float -8.000000e+00, float* %75
store float -7.000000e+00, float* %76
store float -6.000000e+00, float* %77
store float -5.000000e+00, float* %78
%79 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 16, i64 0
%80 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 17, i64 0
%81 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 18, i64 0
%82 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 19, i64 0
store float -4.000000e+00, float* %79
store float -3.000000e+00, float* %80
store float -2.000000e+00, float* %81
store float -1.000000e+00, float* %82
%83 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 20, i64 0
%84 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 21, i64 0
%85 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 22, i64 0
%86 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 23, i64 0
store float 0.000000e+00, float* %83
store float 1.000000e+00, float* %84
store float 2.000000e+00, float* %85
store float 3.000000e+00, float* %86
%87 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 24, i64 0
%88 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 25, i64 0
%89 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 26, i64 0
%90 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 27, i64 0
store float 4.000000e+00, float* %87
store float 5.000000e+00, float* %88
store float 6.000000e+00, float* %89
store float 7.000000e+00, float* %90
%91 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 28, i64 0
%92 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 29, i64 0
%93 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 30, i64 0
%94 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 31, i64 0
store float 8.000000e+00, float* %91
store float 9.000000e+00, float* %92
store float 1.000000e+01, float* %93
store float 1.100000e+01, float* %94
%95 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 32, i64 0
%96 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 33, i64 0
%97 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 34, i64 0
%98 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 35, i64 0
store float 1.200000e+01, float* %95
store float 1.300000e+01, float* %96
store float 1.400000e+01, float* %97
store float 1.500000e+01, float* %98
%99 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 36, i64 0
%100 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 37, i64 0
%101 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 38, i64 0
%102 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 39, i64 0
store float 1.600000e+01, float* %99
store float 1.700000e+01, float* %100
store float 1.800000e+01, float* %101
store float 1.900000e+01, float* %102
%103 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 40, i64 0
store float 2.000000e+01, float* %103
%104 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 41, i64 0
store float 2.100000e+01, float* %104
%105 = fmul double %8, 1.400000e+01
%106 = fmul double %61, -4.990000e-01
%107 = fmul double %61, 5.000000e-01
%108 = fdiv double %61, 1.000000e+03
%109 = fsub double %107, %108
%110 = fpext double %109 to x86_fp80
%111 = fptrunc double %106 to float
%112 = fpext float %111 to x86_fp80
%113 = fcmp olt x86_fp80 %112, %110
%114 = fneg double %61
%115 = fmul double %105, %114
%116 = fmul double %115, 0.000000e+00
%117 = fptrunc double %61 to float
br label %118
118: ; preds = %0, %155
%119 = phi i64 [ -20, %0 ], [ %156, %155 ]
br i1 %113, label %120, label %155
120: ; preds = %118
%121 = trunc i64 %119 to i32
%122 = sitofp i32 %121 to double
%123 = fmul double %122, 0x401921FB54442D11
%124 = add nsw i64 %119, 20
%125 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 %124, i64 1
%126 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 %124, i64 1
br label %127
127: ; preds = %120, %127
%128 = phi float [ %111, %120 ], [ %152, %127 ]
%129 = fpext float %128 to double
%130 = fmul double %123, %129
%131 = fdiv double %130, 0x3E7AD7F29ABCAF48
%132 = fptrunc double %131 to float
%133 = tail call double @pow(float 0x3C07A4DA00000000, i32 2)
%134 = fmul double %116, %133
%135 = fmul double %134, 0x45519FC1CEC0C4CD
%136 = tail call double @pow(float %117, i32 2)
%137 = tail call double @pow(float %128, i32 2)
%138 = fneg double %137
%139 = tail call double @llvm.fmuladd.f64(double %136, double 2.500000e-01, double %138)
%140 = fmul double %13, %139
%141 = fdiv double %135, %140
%142 = fptrunc double %141 to float
%143 = fadd float %132, %142
%144 = tail call float @cos(float %143)
%145 = load float, float* %125
%146 = fadd float %144, %145
store float %146, float* %125
%147 = tail call i64 @sin(float %143)
%148 = sitofp i64 %147 to float
%149 = load float, float* %126
%150 = fadd float %149, %148
store float %150, float* %126
%151 = fadd double %108, %129
%152 = fptrunc double %151 to float
%153 = fpext float %152 to x86_fp80
%154 = fcmp olt x86_fp80 %153, %110
br i1 %154, label %127, label %155
155: ; preds = %127, %118
%156 = add nsw i64 %119, 1
%157 = icmp eq i64 %156, 21
br i1 %157, label %162, label %118
158: ; preds = %162
%159 = bitcast [41 x [2 x float]]* %1 to float**
%160 = call float @x2pnts(float** %159, i32 41, i32 2, float -1.600000e+01)
%161 = fcmp oeq float %160, -1.000000e+00
br i1 %161, label %175, label %177
162: ; preds = %155, %162
%163 = phi i64 [ %173, %162 ], [ 0, %155 ]
%164 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 %163, i64 1
%165 = load float, float* %164
%166 = fdiv float %165, 1.000000e+03
store float %166, float* %164
%167 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %2, i64 0, i64 %163, i64 1
%168 = load float, float* %167
%169 = fdiv float %168, 1.000000e+03
store float %169, float* %167
%170 = trunc i64 %163 to i32
%171 = add i32 %170, -20
%172 = tail call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str, i64 0, i64 0), float %166, i32 %171)
%173 = add nuw nsw i64 %163, 1
%174 = icmp eq i64 %173, 41
br i1 %174, label %158, label %162
175: ; preds = %158
%176 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.1, i64 0, i64 0), float -1.600000e+01)
br label %186
177: ; preds = %158
%178 = fptosi float %160 to i32
%179 = fpext float %160 to double
%180 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.2, i64 0, i64 0), float -1.600000e+01, double %179)
%181 = add nsw i32 %178, -1
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 %182, i64 1
%184 = load float, float* %183
%185 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), float %184)
br label %186
186: ; preds = %177, %175
%187 = call float @x2pnts(float** %159, i32 41, i32 2, float 1.300000e+01)
%188 = fcmp oeq float %187, -1.000000e+00
br i1 %188, label %189, label %191
189: ; preds = %186
%190 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.1, i64 0, i64 0), float 1.300000e+01)
br label %200
191: ; preds = %186
%192 = fptosi float %187 to i32
%193 = fpext float %187 to double
%194 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.2, i64 0, i64 0), float 1.300000e+01, double %193)
%195 = add nsw i32 %192, -1
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 %196, i64 1
%198 = load float, float* %197
%199 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), float %198)
br label %200
200: ; preds = %191, %189
%201 = call float @x2pnts(float** %159, i32 41, i32 2, float 0.000000e+00)
%202 = fcmp oeq float %201, -1.000000e+00
br i1 %202, label %203, label %205
203: ; preds = %200
%204 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.1, i64 0, i64 0), float 0.000000e+00)
br label %214
205: ; preds = %200
%206 = fptosi float %201 to i32
%207 = fpext float %201 to double
%208 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.2, i64 0, i64 0), float 0.000000e+00, double %207)
%209 = add nsw i32 %206, -1
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds [41 x [2 x float]], [41 x [2 x float]]* %1, i64 0, i64 %210, i64 1
%212 = load float, float* %211
%213 = call i32 (i8*, float, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), float %212)
br label %214
214: ; preds = %205, %203
ret i32 0
}