#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 abs(double);
double deriv1(double *, int, int, double);
double deriv2(double *, int, int, double);
double deriv4(double *, int, int, double);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
double function(double *, int, int, double);
int /*<<< orphan*/ sleep(int);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ stdout;
int /*<<< orphan*/ system(char *);
int convergence(double *param, int dimension, int functiontype, double extr_a,
                double extr_b) {
  double funz_extr_a;
  double funz_extr_b;
  int i;
  double h = 0.00000001;
  double DIFF;
  int diff;
  double k;
  system("clear");
  fprintf(stdout, "[*] Discord Images Of The Extremous Points");
  funz_extr_a = function(param, dimension, functiontype, extr_a);
  funz_extr_b = function(param, dimension, functiontype, extr_b);
  if ((funz_extr_a * funz_extr_b) > 0.) {
    fprintf(stdout, " \n");
    fprintf(
        stderr,
        "error: The Images Of The Extremous Points Should Be Discord !!!\n");
    sleep(3);
    return 1;
  }
  if ((funz_extr_a * funz_extr_b) < 0.) {
    fprintf(stdout, "   OK \n");
  }
  DIFF = 1000 * (abs(extr_b - extr_a));
  diff = (int)DIFF;
  double punti[diff];
  punti[0] = extr_a + 0.001;
  k = 1000 * (extr_b - 0.001);
  double neighborhood_dx[diff];
  neighborhood_dx[0] = punti[0] + h;
  double neighborhood_sx[diff];
  neighborhood_sx[0] = punti[0] - h;
  for (i = 1; i < k; i++) {
    punti[i] = punti[i - 1] + 0.001;
    neighborhood_dx[i] = punti[i] + h;
    neighborhood_sx[i] = punti[i] - h;
  }
  fprintf(stdout, "[*] Function Continuous? ");
  double lim_dx[diff];
  double lim_sx[diff];
  double Funz[diff];
  for (i = 1; i < k; i++) {
    lim_dx[i] = function(param, dimension, functiontype, neighborhood_dx[i]);
    lim_sx[i] = function(param, dimension, functiontype, neighborhood_sx[i]);
    Funz[i] = function(param, dimension, functiontype, punti[i]);
    if (abs(lim_dx[i] - lim_sx[i]) > (h * 10000) ||
        abs(lim_dx[i] - Funz[i]) > h * 10000) {
      fprintf(stdout, " \n");
      fprintf(stderr, "error: Function Not Continuous In The Interval !!!\n");
      sleep(3);
      return 2;
    }
  }
  fprintf(stdout, "   OK \n");
  fprintf(stdout, "[*] Derivable? ");
  double Der_dx[diff];
  double Der_sx[diff];
  for (i = 1; i < k; i++) {
    Der_dx[i] = deriv1(param, dimension, functiontype, neighborhood_dx[i]);
    Der_sx[i] = deriv1(param, dimension, functiontype, neighborhood_sx[i]);
    if (abs(Der_dx[i] - Der_sx[i]) > (h * 1000)) {
      fprintf(stdout, " \n");
      fprintf(stderr, "error: Function Not Derivable In The Interval !!!\n");
      sleep(3);
      return 3;
    }
  }
  fprintf(stdout, "   OK \n");
  fprintf(stdout, "[*] Function Monotone? ");
  double Der[diff];
  Der[0] = deriv1(param, dimension, functiontype, punti[0]);
  for (i = 1; i < k; i++) {
    Der[i] = deriv1(param, dimension, functiontype, punti[i]);
    if ((Der[i] * Der[0]) < 0.) {
      fprintf(stdout, " \n");
      fprintf(stderr, "error: Function Not Monotone In The Interval !!!\n");
      sleep(3);
      return 4;
    }
  }
  fprintf(stdout, "   OK \n");
  fprintf(stdout, "[*] First Derivate Continuous? ");
  double lim_dx_D[diff];
  double lim_sx_D[diff];
  for (i = 1; i < k; i++) {
    lim_dx_D[i] = deriv1(param, dimension, functiontype, neighborhood_dx[i]);
    lim_sx_D[i] = deriv1(param, dimension, functiontype, neighborhood_sx[i]);
    if (abs(lim_dx_D[i] - lim_sx_D[i]) > h * 1000 ||
        abs(lim_dx_D[i] - Der[i]) > h * 1000) {
      fprintf(stdout, " \n");
      fprintf(stderr,
              "error: First Derivate Not Continuous In The Interval !!!\n");
      sleep(3);
      return 5;
    }
  }
  fprintf(stdout, "   OK \n");
  fprintf(stdout, "[*] First Derivate Monotone? ");
  int diffder = diff - 2;
  double DerDer[diffder];
  DerDer[0] = deriv2(param, dimension, functiontype, Der[0]);
  for (i = 1; i < k; i++) {
    DerDer[i] = deriv2(param, dimension, functiontype, Der[i]);
    if ((DerDer[i] * DerDer[0]) < 0.) {
      fprintf(stdout, " \n");
      fprintf(
          stderr,
          "error: Second Derivate's Sign Not Continuous In The Interval !!!\n");
      sleep(3);
      return 6;
    }
  }
  fprintf(stdout, "   OK \n");
  if (functiontype == 1 && dimension < 2) {
    return 7;
  }
  fprintf(stdout, "[*] Second Derivate Continuous? ");
  double lim_dx_DD[diff];
  double lim_sx_DD[diff];
  for (i = 1; i < k; i++) {
    lim_dx_DD[i] = deriv2(param, dimension, functiontype, neighborhood_dx[i]);
    lim_sx_DD[i] = deriv2(param, dimension, functiontype, neighborhood_sx[i]);
    if (abs(lim_dx_DD[i] - lim_sx_DD[i]) > h * 1000 ||
        abs(lim_dx_DD[i] - DerDer[i]) > h * 1000) {
      fprintf(stdout, " \n");
      fprintf(stderr,
              "error: Second Derivate Not Continuous In The Interval !!!\n");
      sleep(3);
      return 7;
    }
  }
  fprintf(stdout, "   OK \n");
  if (functiontype == 1 && dimension < 4) {
    return 8;
  }
  fprintf(stdout, "[*] Fourth Continuous Derivate? ");
  double lim_dx_D_q[diff];
  double lim_sx_D_q[diff];
  double Der_q[diff];
  for (i = 1; i < k; i++) {
    lim_dx_D_q[i] = deriv4(param, dimension, functiontype, neighborhood_dx[i]);
    lim_sx_D_q[i] = deriv4(param, dimension, functiontype, neighborhood_sx[i]);
    Der_q[i] = deriv4(param, dimension, functiontype, neighborhood_sx[i]);
    if (abs(lim_dx_D_q[i] - lim_sx_D_q[i]) > h * 1000 ||
        abs(lim_dx_D_q[i] - Der_q[i]) > h * 1000) {
      fprintf(stdout, " \n");
      fprintf(stderr,
              "error: Fourth Derivate Not Continuous In The Interval !!!\n");
      sleep(3);
      return 8;
    }
  }
  fprintf(stdout, "   OK \n");
  return 9;
}


x86 assembly (clang, -O0):
<convergence>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1b0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
movsd  %xmm1,-0x28(%rbp)
movsd  0x1e59(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
lea    0x1e6d(%rip),%rdi
call   1060 <system@plt>
mov    0x3e19(%rip),%rax
mov    (%rax),%edi
lea    0x1e5e(%rip),%rsi
call   1070 <fprintf@plt>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movsd  -0x20(%rbp),%xmm0
call   1090 <function@plt>
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movsd  -0x28(%rbp),%xmm0
call   1090 <function@plt>
movsd  %xmm0,-0x38(%rbp)
movsd  -0x30(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1256 <convergence+0xd6>
mov    0x3dbb(%rip),%rax
mov    (%rax),%edi
lea    0x1e71(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x3dae(%rip),%rax
mov    (%rax),%edi
lea    0x1e16(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x3,%edi
call   10a0 <sleep@plt>
movl   $0x1,-0x4(%rbp)
jmp    2031 <convergence+0xeb1>
movsd  -0x30(%rbp),%xmm1
mulsd  -0x38(%rbp),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1282 <convergence+0x102>
mov    0x3d64(%rip),%rax
mov    (%rax),%edi
lea    0x1e15(%rip),%rsi
call   1070 <fprintf@plt>
movsd  -0x28(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
subsd  %xmm1,%xmm0
call   1030 <abs@plt>
movsd  0x1d6b(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
cvttsd2si -0x50(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x68(%rbp)
lea    0xf(,%rax,8),%rdi
and    $0xfffffffffffffff0,%rdi
mov    %rsp,%rsi
mov    %rsi,%rcx
sub    %rdi,%rcx
mov    %rcx,-0x118(%rbp)
mov    %rcx,%rsp
neg    %rdi
mov    %rax,-0x70(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  0x1d25(%rip),%xmm2
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx)
movsd  -0x28(%rbp),%xmm0
subsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,%r8d
lea    0xf(,%r8,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rax
mov    %rax,%r9
sub    %rdx,%r9
mov    %r9,-0x110(%rbp)
mov    %r9,%rsp
neg    %rdx
mov    %r8,-0x78(%rbp)
movsd  (%rsi,%rdi,1),%xmm0
movsd  -0x48(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rdx,1)
mov    -0x54(%rbp),%eax
mov    %eax,%edx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rax
sub    %rsi,%rax
mov    %rax,-0x108(%rbp)
mov    %rax,%rsp
mov    %rdx,-0x80(%rbp)
movsd  (%rcx),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x3c(%rbp)
cvtsi2sdl -0x3c(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1401 <convergence+0x281>
mov    -0x108(%rbp),%rax
mov    -0x118(%rbp),%rcx
mov    -0x110(%rbp),%rdx
mov    -0x3c(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsd  0x1c59(%rip),%xmm0
addsd  (%rcx,%rsi,8),%xmm0
movslq -0x3c(%rbp),%rsi
movsd  %xmm0,(%rcx,%rsi,8)
movslq -0x3c(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
addsd  -0x48(%rbp),%xmm0
movslq -0x3c(%rbp),%rsi
movsd  %xmm0,(%rdx,%rsi,8)
movslq -0x3c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
subsd  -0x48(%rbp),%xmm0
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    137d <convergence+0x1fd>
mov    0x3bd0(%rip),%rax
mov    (%rax),%edi
lea    0x1c89(%rip),%rsi
call   1070 <fprintf@plt>
mov    -0x54(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x130(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x88(%rbp)
mov    -0x54(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x128(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x90(%rbp)
mov    -0x54(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x120(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x98(%rbp)
movl   $0x1,-0x3c(%rbp)
cvtsi2sdl -0x3c(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1605 <convergence+0x485>
mov    -0x110(%rbp),%rax
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1090 <function@plt>
mov    -0x108(%rbp),%rax
mov    -0x130(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1090 <function@plt>
mov    -0x118(%rbp),%rax
mov    -0x128(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1090 <function@plt>
mov    -0x120(%rbp),%rdx
mov    -0x130(%rbp),%rcx
mov    -0x128(%rbp),%rax
movslq -0x3c(%rbp),%rsi
movsd  %xmm0,(%rdx,%rsi,8)
movslq -0x3c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
call   1030 <abs@plt>
movsd  0x1abb(%rip),%xmm1
mulsd  -0x48(%rbp),%xmm1
ucomisd %xmm1,%xmm0
ja     15a8 <convergence+0x428>
mov    -0x120(%rbp),%rax
mov    -0x130(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
call   1030 <abs@plt>
movsd  0x1a7f(%rip),%xmm1
mulsd  -0x48(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jbe    15f2 <convergence+0x472>
mov    0x3a29(%rip),%rax
mov    (%rax),%edi
lea    0x1adf(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x3a1c(%rip),%rax
mov    (%rax),%edi
lea    0x1ae7(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x3,%edi
call   10a0 <sleep@plt>
movl   $0x2,-0x4(%rbp)
movl   $0x1,-0x9c(%rbp)
jmp    202a <convergence+0xeaa>
jmp    15f7 <convergence+0x477>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    148f <convergence+0x30f>
mov    0x39cc(%rip),%rax
mov    %rax,-0x148(%rbp)
mov    (%rax),%edi
lea    0x1a76(%rip),%rsi
call   1070 <fprintf@plt>
mov    -0x148(%rbp),%rax
mov    (%rax),%edi
lea    0x1ab7(%rip),%rsi
call   1070 <fprintf@plt>
mov    -0x54(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x140(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xa8(%rbp)
mov    -0x54(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x138(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xb0(%rbp)
movl   $0x1,-0x3c(%rbp)
cvtsi2sdl -0x3c(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    178d <convergence+0x60d>
mov    -0x110(%rbp),%rax
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1080 <deriv1@plt>
mov    -0x108(%rbp),%rax
mov    -0x140(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1080 <deriv1@plt>
mov    -0x140(%rbp),%rcx
mov    -0x138(%rbp),%rax
movslq -0x3c(%rbp),%rdx
movsd  %xmm0,(%rax,%rdx,8)
movslq -0x3c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
call   1030 <abs@plt>
movsd  0x18e7(%rip),%xmm1
mulsd  -0x48(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jbe    177a <convergence+0x5fa>
mov    0x38a1(%rip),%rax
mov    (%rax),%edi
lea    0x1957(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x3894(%rip),%rax
mov    (%rax),%edi
lea    0x19a3(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x3,%edi
call   10a0 <sleep@plt>
movl   $0x3,-0x4(%rbp)
movl   $0x1,-0x9c(%rbp)
jmp    202a <convergence+0xeaa>
jmp    177f <convergence+0x5ff>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1689 <convergence+0x509>
mov    0x3844(%rip),%rax
mov    %rax,-0x158(%rbp)
mov    (%rax),%edi
lea    0x18ee(%rip),%rsi
call   1070 <fprintf@plt>
mov    -0x158(%rbp),%rax
mov    (%rax),%edi
lea    0x1972(%rip),%rsi
call   1070 <fprintf@plt>
mov    -0x118(%rbp),%rax
mov    -0x54(%rbp),%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x150(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0xb8(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movsd  (%rax),%xmm0
call   1080 <deriv1@plt>
mov    -0x150(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x3c(%rbp)
cvtsi2sdl -0x3c(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    18ca <convergence+0x74a>
mov    -0x118(%rbp),%rax
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1080 <deriv1@plt>
mov    -0x150(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  (%rax),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    18b7 <convergence+0x737>
mov    0x3764(%rip),%rax
mov    (%rax),%edi
lea    0x181a(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x3757(%rip),%rax
mov    (%rax),%edi
lea    0x18b1(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x3,%edi
call   10a0 <sleep@plt>
movl   $0x4,-0x4(%rbp)
movl   $0x1,-0x9c(%rbp)
jmp    202a <convergence+0xeaa>
jmp    18bc <convergence+0x73c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1810 <convergence+0x690>
mov    0x3707(%rip),%rax
mov    %rax,-0x170(%rbp)
mov    (%rax),%edi
lea    0x17b1(%rip),%rsi
call   1070 <fprintf@plt>
mov    -0x170(%rbp),%rax
mov    (%rax),%edi
lea    0x187f(%rip),%rsi
call   1070 <fprintf@plt>
mov    -0x54(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x168(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xc0(%rbp)
mov    -0x54(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x160(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xc8(%rbp)
movl   $0x1,-0x3c(%rbp)
cvtsi2sdl -0x3c(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1a8e <convergence+0x90e>
mov    -0x110(%rbp),%rax
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1080 <deriv1@plt>
mov    -0x108(%rbp),%rax
mov    -0x168(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1080 <deriv1@plt>
mov    -0x168(%rbp),%rcx
mov    -0x160(%rbp),%rax
movslq -0x3c(%rbp),%rdx
movsd  %xmm0,(%rax,%rdx,8)
movslq -0x3c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
call   1030 <abs@plt>
movsd  0x1622(%rip),%xmm1
mulsd  -0x48(%rbp),%xmm1
ucomisd %xmm1,%xmm0
ja     1a31 <convergence+0x8b1>
mov    -0x150(%rbp),%rax
mov    -0x168(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
call   1030 <abs@plt>
movsd  0x15e6(%rip),%xmm1
mulsd  -0x48(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jbe    1a7b <convergence+0x8fb>
mov    0x35a0(%rip),%rax
mov    (%rax),%edi
lea    0x1656(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x3593(%rip),%rax
mov    (%rax),%edi
lea    0x173f(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x3,%edi
call   10a0 <sleep@plt>
movl   $0x5,-0x4(%rbp)
movl   $0x1,-0x9c(%rbp)
jmp    202a <convergence+0xeaa>
jmp    1a80 <convergence+0x900>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    194e <convergence+0x7ce>
mov    0x3543(%rip),%rax
mov    %rax,-0x180(%rbp)
mov    (%rax),%edi
lea    0x15ed(%rip),%rsi
call   1070 <fprintf@plt>
mov    -0x180(%rbp),%rax
mov    (%rax),%edi
lea    0x1715(%rip),%rsi
call   1070 <fprintf@plt>
mov    -0x150(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0xfffffffe,%ecx
mov    %ecx,-0xcc(%rbp)
mov    -0xcc(%rbp),%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x178(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0xd8(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movsd  (%rax),%xmm0
call   1050 <deriv2@plt>
mov    -0x178(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x3c(%rbp)
cvtsi2sdl -0x3c(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1bda <convergence+0xa5a>
mov    -0x150(%rbp),%rax
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1050 <deriv2@plt>
mov    -0x178(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  (%rax),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1bc7 <convergence+0xa47>
mov    0x3454(%rip),%rax
mov    (%rax),%edi
lea    0x150a(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x3447(%rip),%rax
mov    (%rax),%edi
lea    0x164b(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x3,%edi
call   10a0 <sleep@plt>
movl   $0x6,-0x4(%rbp)
movl   $0x1,-0x9c(%rbp)
jmp    202a <convergence+0xeaa>
jmp    1bcc <convergence+0xa4c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1b20 <convergence+0x9a0>
mov    0x33f7(%rip),%rax
mov    (%rax),%edi
lea    0x14a8(%rip),%rsi
call   1070 <fprintf@plt>
cmpl   $0x1,-0x18(%rbp)
jne    1c19 <convergence+0xa99>
cmpl   $0x2,-0x14(%rbp)
jge    1c19 <convergence+0xa99>
movl   $0x7,-0x4(%rbp)
movl   $0x1,-0x9c(%rbp)
jmp    202a <convergence+0xeaa>
mov    0x33b8(%rip),%rax
mov    (%rax),%edi
lea    0x1606(%rip),%rsi
call   1070 <fprintf@plt>
mov    -0x54(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x190(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xe0(%rbp)
mov    -0x54(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x188(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xe8(%rbp)
movl   $0x1,-0x3c(%rbp)
cvtsi2sdl -0x3c(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1dc1 <convergence+0xc41>
mov    -0x110(%rbp),%rax
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1050 <deriv2@plt>
mov    -0x108(%rbp),%rax
mov    -0x190(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1050 <deriv2@plt>
mov    -0x190(%rbp),%rcx
mov    -0x188(%rbp),%rax
movslq -0x3c(%rbp),%rdx
movsd  %xmm0,(%rax,%rdx,8)
movslq -0x3c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
call   1030 <abs@plt>
movsd  0x12ef(%rip),%xmm1
mulsd  -0x48(%rbp),%xmm1
ucomisd %xmm1,%xmm0
ja     1d64 <convergence+0xbe4>
mov    -0x178(%rbp),%rax
mov    -0x190(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
call   1030 <abs@plt>
movsd  0x12b3(%rip),%xmm1
mulsd  -0x48(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jbe    1dae <convergence+0xc2e>
mov    0x326d(%rip),%rax
mov    (%rax),%edi
lea    0x1323(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x3260(%rip),%rax
mov    (%rax),%edi
lea    0x14c7(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x3,%edi
call   10a0 <sleep@plt>
movl   $0x7,-0x4(%rbp)
movl   $0x1,-0x9c(%rbp)
jmp    202a <convergence+0xeaa>
jmp    1db3 <convergence+0xc33>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1c81 <convergence+0xb01>
mov    0x3210(%rip),%rax
mov    (%rax),%edi
lea    0x12c1(%rip),%rsi
call   1070 <fprintf@plt>
cmpl   $0x1,-0x18(%rbp)
jne    1e00 <convergence+0xc80>
cmpl   $0x4,-0x14(%rbp)
jge    1e00 <convergence+0xc80>
movl   $0x8,-0x4(%rbp)
movl   $0x1,-0x9c(%rbp)
jmp    202a <convergence+0xeaa>
mov    0x31d1(%rip),%rax
mov    (%rax),%edi
lea    0x147b(%rip),%rsi
call   1070 <fprintf@plt>
mov    -0x54(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1a8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xf0(%rbp)
mov    -0x54(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1a0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xf8(%rbp)
mov    -0x54(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x198(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x100(%rbp)
movl   $0x1,-0x3c(%rbp)
cvtsi2sdl -0x3c(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    2004 <convergence+0xe84>
mov    -0x110(%rbp),%rax
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1040 <deriv4@plt>
mov    -0x108(%rbp),%rax
mov    -0x1a8(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1040 <deriv4@plt>
mov    -0x108(%rbp),%rax
mov    -0x1a0(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1040 <deriv4@plt>
mov    -0x198(%rbp),%rdx
mov    -0x1a8(%rbp),%rcx
mov    -0x1a0(%rbp),%rax
movslq -0x3c(%rbp),%rsi
movsd  %xmm0,(%rdx,%rsi,8)
movslq -0x3c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
call   1030 <abs@plt>
movsd  0x10ac(%rip),%xmm1
mulsd  -0x48(%rbp),%xmm1
ucomisd %xmm1,%xmm0
ja     1fa7 <convergence+0xe27>
mov    -0x198(%rbp),%rax
mov    -0x1a8(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
call   1030 <abs@plt>
movsd  0x1070(%rip),%xmm1
mulsd  -0x48(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jbe    1ff1 <convergence+0xe71>
mov    0x302a(%rip),%rax
mov    (%rax),%edi
lea    0x10e0(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x301d(%rip),%rax
mov    (%rax),%edi
lea    0x12e0(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x3,%edi
call   10a0 <sleep@plt>
movl   $0x8,-0x4(%rbp)
movl   $0x1,-0x9c(%rbp)
jmp    202a <convergence+0xeaa>
jmp    1ff6 <convergence+0xe76>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1e8e <convergence+0xd0e>
mov    0x2fcd(%rip),%rax
mov    (%rax),%edi
lea    0x107e(%rip),%rsi
call   1070 <fprintf@plt>
movl   $0x9,-0x4(%rbp)
movl   $0x1,-0x9c(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<convergence>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
movsd  %xmm1,-0x30(%rbp)
movsd  %xmm0,-0x40(%rbp)
mov    %edx,%r14d
mov    %esi,%r15d
mov    %rdi,%rbx
lea    0xe9d(%rip),%rdi
call   1060 <system@plt>
mov    0x2e21(%rip),%r12
mov    (%r12),%edi
lea    0xe8c(%rip),%rsi
call   1070 <fprintf@plt>
mov    %rbx,%rdi
mov    %r15d,%esi
mov    %r14d,%edx
movsd  -0x40(%rbp),%xmm0
call   1090 <function@plt>
movsd  %xmm0,-0x60(%rbp)
mov    %rbx,-0x50(%rbp)
mov    %rbx,%rdi
mov    %r15d,%esi
mov    %r14d,%edx
movsd  -0x30(%rbp),%xmm0
call   1090 <function@plt>
mulsd  -0x60(%rbp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    123e <convergence+0xbe>
mov    (%r12),%edi
lea    0xeaf(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x2dc4(%rip),%rax
mov    (%rax),%edi
lea    0xe54(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x3,%edi
call   10a0 <sleep@plt>
mov    $0x1,%ebx
jmp    1b06 <convergence+0x986>
ucomisd %xmm0,%xmm1
jbe    1254 <convergence+0xd4>
mov    (%r12),%edi
lea    0xe6b(%rip),%rsi
call   1070 <fprintf@plt>
movsd  -0x30(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
call   1030 <abs@plt>
movsd  -0x40(%rbp),%xmm3
movsd  -0x30(%rbp),%xmm5
mov    %rsp,%rax
movsd  0xd88(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%r13
sub    %rsi,%r13
mov    %r13,%rsp
addsd  0xd6b(%rip),%xmm3
movsd  %xmm3,0x0(%r13)
addsd  0xd65(%rip),%xmm5
mulsd  %xmm1,%xmm5
mov    %rsp,%rbx
sub    %rsi,%rbx
mov    %rbx,%rsp
movsd  0xd58(%rip),%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,(%rbx)
mov    %rsp,%rcx
sub    %rsi,%rcx
mov    %rcx,%rsp
movsd  0xd47(%rip),%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx)
ucomisd 0xd3f(%rip),%xmm5
movsd  %xmm5,-0x30(%rbp)
mov    %rax,-0x48(%rbp)
mov    %rbx,-0x60(%rbp)
mov    %rcx,-0x68(%rbp)
mov    %rdx,-0x70(%rbp)
movsd  %xmm3,-0x40(%rbp)
mov    %rsi,-0x78(%rbp)
jbe    144c <convergence+0x2cc>
mov    $0x1,%eax
movsd  0xcee(%rip),%xmm0
movsd  0xcf6(%rip),%xmm1
movsd  0xcf6(%rip),%xmm2
nopw   0x0(%rax,%rax,1)
addsd  %xmm0,%xmm3
movsd  %xmm3,0x0(%r13,%rax,8)
movapd %xmm3,%xmm4
addsd  %xmm1,%xmm4
movsd  %xmm4,(%rbx,%rax,8)
movapd %xmm3,%xmm4
addsd  %xmm2,%xmm4
movsd  %xmm4,(%rcx,%rax,8)
add    $0x1,%rax
xorps  %xmm4,%xmm4
cvtsi2sd %eax,%xmm4
ucomisd %xmm4,%xmm5
ja     1330 <convergence+0x1b0>
mov    (%r12),%edi
lea    0xd51(%rip),%rsi
call   1070 <fprintf@plt>
movsd  -0x30(%rbp),%xmm0
ucomisd 0xca5(%rip),%xmm0
jbe    150b <convergence+0x38b>
mov    $0x1,%ebx
mov    -0x50(%rbp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x60(%rbp),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    %r12,%rdi
mov    %r15d,%esi
mov    %r14d,%edx
call   1090 <function@plt>
movsd  %xmm0,-0x38(%rbp)
mov    -0x68(%rbp),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    %r12,%rdi
mov    %r15d,%esi
mov    %r14d,%edx
call   1090 <function@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  0x0(%r13,%rbx,8),%xmm0
mov    %r12,%rdi
mov    %r15d,%esi
mov    %r14d,%edx
call   1090 <function@plt>
movsd  %xmm0,-0x80(%rbp)
movsd  -0x38(%rbp),%xmm0
subsd  -0x58(%rbp),%xmm0
call   1030 <abs@plt>
ucomisd 0xc27(%rip),%xmm0
ja     1a12 <convergence+0x892>
movsd  -0x38(%rbp),%xmm0
subsd  -0x80(%rbp),%xmm0
call   1030 <abs@plt>
movsd  0xc0a(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     1a12 <convergence+0x892>
add    $0x1,%rbx
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movsd  -0x30(%rbp),%xmm1
ucomisd %xmm0,%xmm1
ja     13a0 <convergence+0x220>
jmp    145c <convergence+0x2dc>
mov    (%r12),%edi
lea    0xc6b(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x2b75(%rip),%rbx
mov    (%rbx),%edi
lea    0xc4e(%rip),%rsi
call   1070 <fprintf@plt>
mov    (%rbx),%edi
lea    0xc96(%rip),%rsi
call   1070 <fprintf@plt>
movsd  -0x30(%rbp),%xmm0
ucomisd 0xb9c(%rip),%xmm0
jbe    152b <convergence+0x3ab>
mov    $0x1,%ebx
mov    -0x50(%rbp),%r12
nopl   0x0(%rax,%rax,1)
mov    -0x60(%rbp),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    %r12,%rdi
mov    %r15d,%esi
mov    %r14d,%edx
call   1080 <deriv1@plt>
movsd  %xmm0,-0x38(%rbp)
mov    -0x68(%rbp),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    %r12,%rdi
mov    %r15d,%esi
mov    %r14d,%edx
call   1080 <deriv1@plt>
movsd  -0x38(%rbp),%xmm1
subsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
call   1030 <abs@plt>
ucomisd 0xb4b(%rip),%xmm0
ja     1a50 <convergence+0x8d0>
add    $0x1,%rbx
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movsd  -0x30(%rbp),%xmm1
ucomisd %xmm0,%xmm1
ja     14a0 <convergence+0x320>
jmp    152b <convergence+0x3ab>
mov    (%r12),%edi
lea    0xba4(%rip),%rsi
call   1070 <fprintf@plt>
mov    (%r12),%edi
lea    0xbea(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x2aa6(%rip),%rbx
mov    (%rbx),%edi
lea    0xb7f(%rip),%rsi
call   1070 <fprintf@plt>
mov    (%rbx),%edi
lea    0xc0a(%rip),%rsi
call   1070 <fprintf@plt>
mov    %rsp,%r12
mov    %r12,-0x58(%rbp)
mov    -0x78(%rbp),%rbx
sub    %rbx,%r12
mov    %r12,%rsp
neg    %rbx
mov    -0x50(%rbp),%rdi
mov    %r15d,%esi
mov    %r14d,%edx
movsd  -0x40(%rbp),%xmm0
call   1080 <deriv1@plt>
movapd %xmm0,%xmm1
movsd  -0x30(%rbp),%xmm0
ucomisd 0xaa1(%rip),%xmm0
movsd  %xmm1,-0x38(%rbp)
mov    -0x58(%rbp),%rax
movsd  %xmm1,(%rax,%rbx,1)
jbe    16c1 <convergence+0x541>
mov    $0x1,%ebx
movsd  0x0(%r13,%rbx,8),%xmm0
mov    -0x50(%rbp),%rdi
mov    %r15d,%esi
mov    %r14d,%edx
call   1080 <deriv1@plt>
movsd  %xmm0,(%r12,%rbx,8)
mulsd  -0x38(%rbp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
ja     19d4 <convergence+0x854>
add    $0x1,%rbx
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movsd  -0x30(%rbp),%xmm1
ucomisd %xmm0,%xmm1
ja     15a0 <convergence+0x420>
mov    0x29ec(%rip),%rbx
mov    (%rbx),%edi
lea    0xac5(%rip),%rsi
call   1070 <fprintf@plt>
mov    (%rbx),%edi
lea    0xb9a(%rip),%rsi
call   1070 <fprintf@plt>
movsd  -0x30(%rbp),%xmm0
ucomisd 0xa13(%rip),%xmm0
jbe    16e4 <convergence+0x564>
mov    $0x1,%ebx
mov    -0x50(%rbp),%r13
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x60(%rbp),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    %r13,%rdi
mov    %r15d,%esi
mov    %r14d,%edx
call   1080 <deriv1@plt>
movsd  %xmm0,-0x40(%rbp)
mov    -0x68(%rbp),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    %r13,%rdi
mov    %r15d,%esi
mov    %r14d,%edx
call   1080 <deriv1@plt>
movsd  -0x40(%rbp),%xmm1
subsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
call   1030 <abs@plt>
ucomisd 0x9bb(%rip),%xmm0
ja     1ac6 <convergence+0x946>
movsd  -0x40(%rbp),%xmm0
subsd  (%r12,%rbx,8),%xmm0
call   1030 <abs@plt>
movsd  0x99d(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     1ac6 <convergence+0x946>
add    $0x1,%rbx
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movsd  -0x30(%rbp),%xmm1
ucomisd %xmm0,%xmm1
ja     1630 <convergence+0x4b0>
jmp    16e4 <convergence+0x564>
mov    0x2910(%rip),%rbx
mov    (%rbx),%edi
lea    0x9e9(%rip),%rsi
call   1070 <fprintf@plt>
mov    (%rbx),%edi
lea    0xabe(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x28ed(%rip),%rbx
mov    (%rbx),%edi
lea    0x9c6(%rip),%rsi
call   1070 <fprintf@plt>
mov    (%rbx),%edi
lea    0xaf5(%rip),%rsi
call   1070 <fprintf@plt>
mov    -0x70(%rbp),%rax
add    $0xfffffffe,%eax
mov    %rsp,%r13
mov    %r13,-0x40(%rbp)
lea    0xf(,%rax,8),%rbx
and    $0xfffffffffffffff0,%rbx
sub    %rbx,%r13
mov    %r13,%rsp
neg    %rbx
mov    -0x50(%rbp),%rdi
mov    %r15d,%esi
mov    %r14d,%edx
movsd  -0x38(%rbp),%xmm0
call   1050 <deriv2@plt>
movapd %xmm0,%xmm1
movsd  -0x30(%rbp),%xmm0
ucomisd 0x8d9(%rip),%xmm0
movsd  %xmm1,-0x38(%rbp)
mov    -0x40(%rbp),%rax
movsd  %xmm1,(%rax,%rbx,1)
jbe    17b5 <convergence+0x635>
mov    $0x1,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r12,%rbx,8),%xmm0
mov    -0x50(%rbp),%rdi
mov    %r15d,%esi
mov    %r14d,%edx
call   1050 <deriv2@plt>
movsd  %xmm0,0x0(%r13,%rbx,8)
mulsd  -0x38(%rbp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
ja     1a8b <convergence+0x90b>
add    $0x1,%rbx
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movsd  -0x30(%rbp),%xmm1
ucomisd %xmm0,%xmm1
ja     1770 <convergence+0x5f0>
mov    0x281c(%rip),%r12
mov    (%r12),%edi
lea    0x8f3(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x7,%ebx
cmp    $0x1,%r15d
mov    -0x48(%rbp),%rax
jg     17e5 <convergence+0x665>
cmp    $0x1,%r14d
je     1b03 <convergence+0x983>
mov    (%r12),%edi
lea    0xa67(%rip),%rsi
call   1070 <fprintf@plt>
movsd  -0x30(%rbp),%xmm0
ucomisd 0x826(%rip),%xmm0
jbe    18b0 <convergence+0x730>
mov    $0x1,%ebx
mov    -0x50(%rbp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x60(%rbp),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    %r12,%rdi
mov    %r15d,%esi
mov    %r14d,%edx
call   1050 <deriv2@plt>
movsd  %xmm0,-0x38(%rbp)
mov    -0x68(%rbp),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    %r12,%rdi
mov    %r15d,%esi
mov    %r14d,%edx
call   1050 <deriv2@plt>
movsd  -0x38(%rbp),%xmm1
subsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
call   1030 <abs@plt>
ucomisd 0x7cb(%rip),%xmm0
ja     1b17 <convergence+0x997>
movsd  -0x38(%rbp),%xmm0
subsd  0x0(%r13,%rbx,8),%xmm0
call   1030 <abs@plt>
movsd  0x7ac(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     1b17 <convergence+0x997>
add    $0x1,%rbx
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movsd  -0x30(%rbp),%xmm1
ucomisd %xmm0,%xmm1
ja     1820 <convergence+0x6a0>
mov    0x2721(%rip),%r12
mov    (%r12),%edi
lea    0x7f8(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x8,%ebx
cmp    $0x3,%r15d
jg     18dc <convergence+0x75c>
cmp    $0x1,%r14d
je     1aff <convergence+0x97f>
mov    (%r12),%edi
lea    0x9cc(%rip),%rsi
call   1070 <fprintf@plt>
movsd  -0x30(%rbp),%xmm0
ucomisd 0x72f(%rip),%xmm0
jbe    19b5 <convergence+0x835>
mov    $0x1,%ebx
mov    -0x50(%rbp),%r12
mov    -0x60(%rbp),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    %r12,%rdi
mov    %r15d,%esi
mov    %r14d,%edx
call   1040 <deriv4@plt>
movsd  %xmm0,-0x38(%rbp)
mov    -0x68(%rbp),%rax
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    %r12,%rdi
mov    %r15d,%esi
mov    %r14d,%edx
call   1040 <deriv4@plt>
movsd  %xmm0,-0x40(%rbp)
mov    %r12,%rdi
mov    %r15d,%esi
mov    %r14d,%edx
movsd  -0x58(%rbp),%xmm0
call   1040 <deriv4@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x38(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
call   1030 <abs@plt>
ucomisd 0x6c4(%rip),%xmm0
ja     1b56 <convergence+0x9d6>
movsd  -0x38(%rbp),%xmm0
subsd  -0x58(%rbp),%xmm0
call   1030 <abs@plt>
movsd  0x6a7(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     1b56 <convergence+0x9d6>
add    $0x1,%rbx
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movsd  -0x30(%rbp),%xmm1
ucomisd %xmm0,%xmm1
ja     1908 <convergence+0x788>
mov    0x261c(%rip),%rax
mov    (%rax),%edi
lea    0x6f5(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x9,%ebx
jmp    1aff <convergence+0x97f>
mov    0x25fd(%rip),%rax
mov    (%rax),%edi
lea    0x6db(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x25f0(%rip),%rax
mov    (%rax),%edi
lea    0x772(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x3,%edi
call   10a0 <sleep@plt>
mov    $0x4,%ebx
jmp    1aff <convergence+0x97f>
mov    0x25bf(%rip),%rax
mov    (%rax),%edi
lea    0x69d(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x25b2(%rip),%rax
mov    (%rax),%edi
lea    0x6a5(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x3,%edi
call   10a0 <sleep@plt>
mov    $0x2,%ebx
jmp    1aff <convergence+0x97f>
mov    0x2581(%rip),%rax
mov    (%rax),%edi
lea    0x65f(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x2574(%rip),%rax
mov    (%rax),%edi
lea    0x6ab(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x3,%ebx
mov    $0x3,%edi
call   10a0 <sleep@plt>
jmp    1aff <convergence+0x97f>
mov    0x2546(%rip),%rax
mov    (%rax),%edi
lea    0x624(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x2539(%rip),%rax
mov    (%rax),%edi
lea    0x765(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x3,%edi
call   10a0 <sleep@plt>
mov    $0x6,%ebx
jmp    1aff <convergence+0x97f>
mov    0x250b(%rip),%rax
mov    (%rax),%edi
lea    0x5e9(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x24fe(%rip),%rax
mov    (%rax),%edi
lea    0x6d2(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x3,%edi
call   10a0 <sleep@plt>
mov    $0x5,%ebx
mov    -0x48(%rbp),%rax
mov    %rax,%rsp
mov    %ebx,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x24ba(%rip),%rax
mov    (%rax),%edi
lea    0x598(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x24ad(%rip),%rax
mov    (%rax),%edi
lea    0x73c(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x3,%edi
call   10a0 <sleep@plt>
mov    -0x48(%rbp),%rax
mov    $0x7,%ebx
jmp    1b03 <convergence+0x983>
mov    0x247b(%rip),%rax
mov    (%rax),%edi
lea    0x559(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x246e(%rip),%rax
mov    (%rax),%edi
lea    0x759(%rip),%rsi
call   1070 <fprintf@plt>
mov    $0x3,%edi
call   10a0 <sleep@plt>
mov    -0x48(%rbp),%rax
mov    $0x8,%ebx
jmp    1b03 <convergence+0x983>

LLVM IR (-O0):
@.str = [6 x i8] c"clear\00"
@stdout = global i32 0
@.str.1 = [43 x i8] c"[*] Discord Images Of The Extremous Points\00"
@.str.2 = [3 x i8] c" \0A\00"
@stderr = global i32 0
@.str.3 = [65 x i8] c"error: The Images Of The Extremous Points Should Be Discord !!!\0A\00"
@.str.4 = [8 x i8] c" OK \0A\00"
@.str.5 = [26 x i8] c"[*] Function Continuous? \00"
@.str.6 = [52 x i8] c"error: Function Not Continuous In The Interval !!!\0A\00"
@.str.7 = [16 x i8] c"[*] Derivable? \00"
@.str.8 = [51 x i8] c"error: Function Not Derivable In The Interval !!!\0A\00"
@.str.9 = [24 x i8] c"[*] Function Monotone? \00"
@.str.10 = [50 x i8] c"error: Function Not Monotone In The Interval !!!\0A\00"
@.str.11 = [32 x i8] c"[*] First Derivate Continuous? \00"
@.str.12 = [58 x i8] c"error: First Derivate Not Continuous In The Interval !!!\0A\00"
@.str.13 = [30 x i8] c"[*] First Derivate Monotone? \00"
@.str.14 = [66 x i8] c"error: Second Derivate's Sign Not Continuous In The Interval !!!\0A\00"
@.str.15 = [33 x i8] c"[*] Second Derivate Continuous? \00"
@.str.16 = [59 x i8] c"error: Second Derivate Not Continuous In The Interval !!!\0A\00"
@.str.17 = [33 x i8] c"[*] Fourth Continuous Derivate? \00"
@.str.18 = [59 x i8] c"error: Fourth Derivate Not Continuous In The Interval !!!\0A\00"
define i32 @convergence(double* %0, i32 %1, i32 %2, double %3, double %4) {
%6 = alloca i32
%7 = alloca double*
%8 = alloca i32
%9 = alloca i32
%10 = alloca double
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca i32
%15 = alloca double
%16 = alloca double
%17 = alloca i32
%18 = alloca double
%19 = alloca i8*
%20 = alloca i64
%21 = alloca i64
%22 = alloca i64
%23 = alloca i64
%24 = alloca i64
%25 = alloca i64
%26 = alloca i32
%27 = alloca i64
%28 = alloca i64
%29 = alloca i64
%30 = alloca i64
%31 = alloca i64
%32 = alloca i32
%33 = alloca i64
%34 = alloca i64
%35 = alloca i64
%36 = alloca i64
%37 = alloca i64
%38 = alloca i64
store double* %0, double** %7
store i32 %1, i32* %8
store i32 %2, i32* %9
store double %3, double* %10
store double %4, double* %11
store double 1.000000e-08, double* %15
%39 = call i32 @system(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
%40 = load i32, i32* @stdout
%41 = call i32 @fprintf(i32 %40, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.1, i64 0, i64 0))
%42 = load double*, double** %7
%43 = load i32, i32* %8
%44 = load i32, i32* %9
%45 = load double, double* %10
%46 = call double @function(double* %42, i32 %43, i32 %44, double %45)
store double %46, double* %12
%47 = load double*, double** %7
%48 = load i32, i32* %8
%49 = load i32, i32* %9
%50 = load double, double* %11
%51 = call double @function(double* %47, i32 %48, i32 %49, double %50)
store double %51, double* %13
%52 = load double, double* %12
%53 = load double, double* %13
%54 = fmul double %52, %53
%55 = fcmp ogt double %54, 0.000000e+00
br i1 %55, label %56, label %62
56: ; preds = %5
%57 = load i32, i32* @stdout
%58 = call i32 @fprintf(i32 %57, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%59 = load i32, i32* @stderr
%60 = call i32 @fprintf(i32 %59, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.3, i64 0, i64 0))
%61 = call i32 @sleep(i32 3)
store i32 1, i32* %6
br label %653
62: ; preds = %5
%63 = load double, double* %12
%64 = load double, double* %13
%65 = fmul double %63, %64
%66 = fcmp olt double %65, 0.000000e+00
br i1 %66, label %67, label %70
67: ; preds = %62
%68 = load i32, i32* @stdout
%69 = call i32 @fprintf(i32 %68, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
br label %70
70: ; preds = %67, %62
%71 = load double, double* %11
%72 = load double, double* %10
%73 = fsub double %71, %72
%74 = call double @abs(double %73)
%75 = fmul double 1.000000e+03, %74
store double %75, double* %16
%76 = load double, double* %16
%77 = fptosi double %76 to i32
store i32 %77, i32* %17
%78 = load i32, i32* %17
%79 = zext i32 %78 to i64
%80 = call i8* @llvm.stacksave()
store i8* %80, i8** %19
%81 = alloca double, i64 %79
store i64 %79, i64* %20
%82 = load double, double* %10
%83 = fadd double %82, 1.000000e-03
%84 = getelementptr inbounds double, double* %81, i64 0
store double %83, double* %84
%85 = load double, double* %11
%86 = fsub double %85, 1.000000e-03
%87 = fmul double 1.000000e+03, %86
store double %87, double* %18
%88 = load i32, i32* %17
%89 = zext i32 %88 to i64
%90 = alloca double, i64 %89
store i64 %89, i64* %21
%91 = getelementptr inbounds double, double* %81, i64 0
%92 = load double, double* %91
%93 = load double, double* %15
%94 = fadd double %92, %93
%95 = getelementptr inbounds double, double* %90, i64 0
store double %94, double* %95
%96 = load i32, i32* %17
%97 = zext i32 %96 to i64
%98 = alloca double, i64 %97
store i64 %97, i64* %22
%99 = getelementptr inbounds double, double* %81, i64 0
%100 = load double, double* %99
%101 = load double, double* %15
%102 = fsub double %100, %101
%103 = getelementptr inbounds double, double* %98, i64 0
store double %102, double* %103
store i32 1, i32* %14
br label %104
104: ; preds = %137, %70
%105 = load i32, i32* %14
%106 = sitofp i32 %105 to double
%107 = load double, double* %18
%108 = fcmp olt double %106, %107
br i1 %108, label %109, label %140
109: ; preds = %104
%110 = load i32, i32* %14
%111 = sub nsw i32 %110, 1
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds double, double* %81, i64 %112
%114 = load double, double* %113
%115 = fadd double %114, 1.000000e-03
%116 = load i32, i32* %14
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds double, double* %81, i64 %117
store double %115, double* %118
%119 = load i32, i32* %14
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds double, double* %81, i64 %120
%122 = load double, double* %121
%123 = load double, double* %15
%124 = fadd double %122, %123
%125 = load i32, i32* %14
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds double, double* %90, i64 %126
store double %124, double* %127
%128 = load i32, i32* %14
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double, double* %81, i64 %129
%131 = load double, double* %130
%132 = load double, double* %15
%133 = fsub double %131, %132
%134 = load i32, i32* %14
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %98, i64 %135
store double %133, double* %136
br label %137
137: ; preds = %109
%138 = load i32, i32* %14
%139 = add nsw i32 %138, 1
store i32 %139, i32* %14
br label %104
140: ; preds = %104
%141 = load i32, i32* @stdout
%142 = call i32 @fprintf(i32 %141, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.5, i64 0, i64 0))
%143 = load i32, i32* %17
%144 = zext i32 %143 to i64
%145 = alloca double, i64 %144
store i64 %144, i64* %23
%146 = load i32, i32* %17
%147 = zext i32 %146 to i64
%148 = alloca double, i64 %147
store i64 %147, i64* %24
%149 = load i32, i32* %17
%150 = zext i32 %149 to i64
%151 = alloca double, i64 %150
store i64 %150, i64* %25
store i32 1, i32* %14
br label %152
152: ; preds = %225, %140
%153 = load i32, i32* %14
%154 = sitofp i32 %153 to double
%155 = load double, double* %18
%156 = fcmp olt double %154, %155
br i1 %156, label %157, label %228
157: ; preds = %152
%158 = load double*, double** %7
%159 = load i32, i32* %8
%160 = load i32, i32* %9
%161 = load i32, i32* %14
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds double, double* %90, i64 %162
%164 = load double, double* %163
%165 = call double @function(double* %158, i32 %159, i32 %160, double %164)
%166 = load i32, i32* %14
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds double, double* %145, i64 %167
store double %165, double* %168
%169 = load double*, double** %7
%170 = load i32, i32* %8
%171 = load i32, i32* %9
%172 = load i32, i32* %14
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds double, double* %98, i64 %173
%175 = load double, double* %174
%176 = call double @function(double* %169, i32 %170, i32 %171, double %175)
%177 = load i32, i32* %14
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds double, double* %148, i64 %178
store double %176, double* %179
%180 = load double*, double** %7
%181 = load i32, i32* %8
%182 = load i32, i32* %9
%183 = load i32, i32* %14
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds double, double* %81, i64 %184
%186 = load double, double* %185
%187 = call double @function(double* %180, i32 %181, i32 %182, double %186)
%188 = load i32, i32* %14
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds double, double* %151, i64 %189
store double %187, double* %190
%191 = load i32, i32* %14
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds double, double* %145, i64 %192
%194 = load double, double* %193
%195 = load i32, i32* %14
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds double, double* %148, i64 %196
%198 = load double, double* %197
%199 = fsub double %194, %198
%200 = call double @abs(double %199)
%201 = load double, double* %15
%202 = fmul double %201, 1.000000e+04
%203 = fcmp ogt double %200, %202
br i1 %203, label %218, label %204
204: ; preds = %157
%205 = load i32, i32* %14
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds double, double* %145, i64 %206
%208 = load double, double* %207
%209 = load i32, i32* %14
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds double, double* %151, i64 %210
%212 = load double, double* %211
%213 = fsub double %208, %212
%214 = call double @abs(double %213)
%215 = load double, double* %15
%216 = fmul double %215, 1.000000e+04
%217 = fcmp ogt double %214, %216
br i1 %217, label %218, label %224
218: ; preds = %204, %157
%219 = load i32, i32* @stdout
%220 = call i32 @fprintf(i32 %219, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%221 = load i32, i32* @stderr
%222 = call i32 @fprintf(i32 %221, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.6, i64 0, i64 0))
%223 = call i32 @sleep(i32 3)
store i32 2, i32* %6
store i32 1, i32* %26
br label %651
224: ; preds = %204
br label %225
225: ; preds = %224
%226 = load i32, i32* %14
%227 = add nsw i32 %226, 1
store i32 %227, i32* %14
br label %152
228: ; preds = %152
%229 = load i32, i32* @stdout
%230 = call i32 @fprintf(i32 %229, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%231 = load i32, i32* @stdout
%232 = call i32 @fprintf(i32 %231, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.7, i64 0, i64 0))
%233 = load i32, i32* %17
%234 = zext i32 %233 to i64
%235 = alloca double, i64 %234
store i64 %234, i64* %27
%236 = load i32, i32* %17
%237 = zext i32 %236 to i64
%238 = alloca double, i64 %237
store i64 %237, i64* %28
store i32 1, i32* %14
br label %239
239: ; preds = %287, %228
%240 = load i32, i32* %14
%241 = sitofp i32 %240 to double
%242 = load double, double* %18
%243 = fcmp olt double %241, %242
br i1 %243, label %244, label %290
244: ; preds = %239
%245 = load double*, double** %7
%246 = load i32, i32* %8
%247 = load i32, i32* %9
%248 = load i32, i32* %14
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds double, double* %90, i64 %249
%251 = load double, double* %250
%252 = call double @deriv1(double* %245, i32 %246, i32 %247, double %251)
%253 = load i32, i32* %14
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds double, double* %235, i64 %254
store double %252, double* %255
%256 = load double*, double** %7
%257 = load i32, i32* %8
%258 = load i32, i32* %9
%259 = load i32, i32* %14
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds double, double* %98, i64 %260
%262 = load double, double* %261
%263 = call double @deriv1(double* %256, i32 %257, i32 %258, double %262)
%264 = load i32, i32* %14
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds double, double* %238, i64 %265
store double %263, double* %266
%267 = load i32, i32* %14
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds double, double* %235, i64 %268
%270 = load double, double* %269
%271 = load i32, i32* %14
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds double, double* %238, i64 %272
%274 = load double, double* %273
%275 = fsub double %270, %274
%276 = call double @abs(double %275)
%277 = load double, double* %15
%278 = fmul double %277, 1.000000e+03
%279 = fcmp ogt double %276, %278
br i1 %279, label %280, label %286
280: ; preds = %244
%281 = load i32, i32* @stdout
%282 = call i32 @fprintf(i32 %281, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%283 = load i32, i32* @stderr
%284 = call i32 @fprintf(i32 %283, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.8, i64 0, i64 0))
%285 = call i32 @sleep(i32 3)
store i32 3, i32* %6
store i32 1, i32* %26
br label %651
286: ; preds = %244
br label %287
287: ; preds = %286
%288 = load i32, i32* %14
%289 = add nsw i32 %288, 1
store i32 %289, i32* %14
br label %239
290: ; preds = %239
%291 = load i32, i32* @stdout
%292 = call i32 @fprintf(i32 %291, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%293 = load i32, i32* @stdout
%294 = call i32 @fprintf(i32 %293, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.9, i64 0, i64 0))
%295 = load i32, i32* %17
%296 = zext i32 %295 to i64
%297 = alloca double, i64 %296
store i64 %296, i64* %29
%298 = load double*, double** %7
%299 = load i32, i32* %8
%300 = load i32, i32* %9
%301 = getelementptr inbounds double, double* %81, i64 0
%302 = load double, double* %301
%303 = call double @deriv1(double* %298, i32 %299, i32 %300, double %302)
%304 = getelementptr inbounds double, double* %297, i64 0
store double %303, double* %304
store i32 1, i32* %14
br label %305
305: ; preds = %337, %290
%306 = load i32, i32* %14
%307 = sitofp i32 %306 to double
%308 = load double, double* %18
%309 = fcmp olt double %307, %308
br i1 %309, label %310, label %340
310: ; preds = %305
%311 = load double*, double** %7
%312 = load i32, i32* %8
%313 = load i32, i32* %9
%314 = load i32, i32* %14
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds double, double* %81, i64 %315
%317 = load double, double* %316
%318 = call double @deriv1(double* %311, i32 %312, i32 %313, double %317)
%319 = load i32, i32* %14
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds double, double* %297, i64 %320
store double %318, double* %321
%322 = load i32, i32* %14
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds double, double* %297, i64 %323
%325 = load double, double* %324
%326 = getelementptr inbounds double, double* %297, i64 0
%327 = load double, double* %326
%328 = fmul double %325, %327
%329 = fcmp olt double %328, 0.000000e+00
br i1 %329, label %330, label %336
330: ; preds = %310
%331 = load i32, i32* @stdout
%332 = call i32 @fprintf(i32 %331, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%333 = load i32, i32* @stderr
%334 = call i32 @fprintf(i32 %333, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.10, i64 0, i64 0))
%335 = call i32 @sleep(i32 3)
store i32 4, i32* %6
store i32 1, i32* %26
br label %651
336: ; preds = %310
br label %337
337: ; preds = %336
%338 = load i32, i32* %14
%339 = add nsw i32 %338, 1
store i32 %339, i32* %14
br label %305
340: ; preds = %305
%341 = load i32, i32* @stdout
%342 = call i32 @fprintf(i32 %341, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%343 = load i32, i32* @stdout
%344 = call i32 @fprintf(i32 %343, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.11, i64 0, i64 0))
%345 = load i32, i32* %17
%346 = zext i32 %345 to i64
%347 = alloca double, i64 %346
store i64 %346, i64* %30
%348 = load i32, i32* %17
%349 = zext i32 %348 to i64
%350 = alloca double, i64 %349
store i64 %349, i64* %31
store i32 1, i32* %14
br label %351
351: ; preds = %413, %340
%352 = load i32, i32* %14
%353 = sitofp i32 %352 to double
%354 = load double, double* %18
%355 = fcmp olt double %353, %354
br i1 %355, label %356, label %416
356: ; preds = %351
%357 = load double*, double** %7
%358 = load i32, i32* %8
%359 = load i32, i32* %9
%360 = load i32, i32* %14
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds double, double* %90, i64 %361
%363 = load double, double* %362
%364 = call double @deriv1(double* %357, i32 %358, i32 %359, double %363)
%365 = load i32, i32* %14
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds double, double* %347, i64 %366
store double %364, double* %367
%368 = load double*, double** %7
%369 = load i32, i32* %8
%370 = load i32, i32* %9
%371 = load i32, i32* %14
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds double, double* %98, i64 %372
%374 = load double, double* %373
%375 = call double @deriv1(double* %368, i32 %369, i32 %370, double %374)
%376 = load i32, i32* %14
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds double, double* %350, i64 %377
store double %375, double* %378
%379 = load i32, i32* %14
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds double, double* %347, i64 %380
%382 = load double, double* %381
%383 = load i32, i32* %14
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds double, double* %350, i64 %384
%386 = load double, double* %385
%387 = fsub double %382, %386
%388 = call double @abs(double %387)
%389 = load double, double* %15
%390 = fmul double %389, 1.000000e+03
%391 = fcmp ogt double %388, %390
br i1 %391, label %406, label %392
392: ; preds = %356
%393 = load i32, i32* %14
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds double, double* %347, i64 %394
%396 = load double, double* %395
%397 = load i32, i32* %14
%398 = sext i32 %397 to i64
%399 = getelementptr inbounds double, double* %297, i64 %398
%400 = load double, double* %399
%401 = fsub double %396, %400
%402 = call double @abs(double %401)
%403 = load double, double* %15
%404 = fmul double %403, 1.000000e+03
%405 = fcmp ogt double %402, %404
br i1 %405, label %406, label %412
406: ; preds = %392, %356
%407 = load i32, i32* @stdout
%408 = call i32 @fprintf(i32 %407, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%409 = load i32, i32* @stderr
%410 = call i32 @fprintf(i32 %409, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.12, i64 0, i64 0))
%411 = call i32 @sleep(i32 3)
store i32 5, i32* %6
store i32 1, i32* %26
br label %651
412: ; preds = %392
br label %413
413: ; preds = %412
%414 = load i32, i32* %14
%415 = add nsw i32 %414, 1
store i32 %415, i32* %14
br label %351
416: ; preds = %351
%417 = load i32, i32* @stdout
%418 = call i32 @fprintf(i32 %417, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%419 = load i32, i32* @stdout
%420 = call i32 @fprintf(i32 %419, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.13, i64 0, i64 0))
%421 = load i32, i32* %17
%422 = sub nsw i32 %421, 2
store i32 %422, i32* %32
%423 = load i32, i32* %32
%424 = zext i32 %423 to i64
%425 = alloca double, i64 %424
store i64 %424, i64* %33
%426 = load double*, double** %7
%427 = load i32, i32* %8
%428 = load i32, i32* %9
%429 = getelementptr inbounds double, double* %297, i64 0
%430 = load double, double* %429
%431 = call double @deriv2(double* %426, i32 %427, i32 %428, double %430)
%432 = getelementptr inbounds double, double* %425, i64 0
store double %431, double* %432
store i32 1, i32* %14
br label %433
433: ; preds = %465, %416
%434 = load i32, i32* %14
%435 = sitofp i32 %434 to double
%436 = load double, double* %18
%437 = fcmp olt double %435, %436
br i1 %437, label %438, label %468
438: ; preds = %433
%439 = load double*, double** %7
%440 = load i32, i32* %8
%441 = load i32, i32* %9
%442 = load i32, i32* %14
%443 = sext i32 %442 to i64
%444 = getelementptr inbounds double, double* %297, i64 %443
%445 = load double, double* %444
%446 = call double @deriv2(double* %439, i32 %440, i32 %441, double %445)
%447 = load i32, i32* %14
%448 = sext i32 %447 to i64
%449 = getelementptr inbounds double, double* %425, i64 %448
store double %446, double* %449
%450 = load i32, i32* %14
%451 = sext i32 %450 to i64
%452 = getelementptr inbounds double, double* %425, i64 %451
%453 = load double, double* %452
%454 = getelementptr inbounds double, double* %425, i64 0
%455 = load double, double* %454
%456 = fmul double %453, %455
%457 = fcmp olt double %456, 0.000000e+00
br i1 %457, label %458, label %464
458: ; preds = %438
%459 = load i32, i32* @stdout
%460 = call i32 @fprintf(i32 %459, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%461 = load i32, i32* @stderr
%462 = call i32 @fprintf(i32 %461, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.14, i64 0, i64 0))
%463 = call i32 @sleep(i32 3)
store i32 6, i32* %6
store i32 1, i32* %26
br label %651
464: ; preds = %438
br label %465
465: ; preds = %464
%466 = load i32, i32* %14
%467 = add nsw i32 %466, 1
store i32 %467, i32* %14
br label %433
468: ; preds = %433
%469 = load i32, i32* @stdout
%470 = call i32 @fprintf(i32 %469, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%471 = load i32, i32* %9
%472 = icmp eq i32 %471, 1
br i1 %472, label %473, label %477
473: ; preds = %468
%474 = load i32, i32* %8
%475 = icmp slt i32 %474, 2
br i1 %475, label %476, label %477
476: ; preds = %473
store i32 7, i32* %6
store i32 1, i32* %26
br label %651
477: ; preds = %473, %468
%478 = load i32, i32* @stdout
%479 = call i32 @fprintf(i32 %478, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.15, i64 0, i64 0))
%480 = load i32, i32* %17
%481 = zext i32 %480 to i64
%482 = alloca double, i64 %481
store i64 %481, i64* %34
%483 = load i32, i32* %17
%484 = zext i32 %483 to i64
%485 = alloca double, i64 %484
store i64 %484, i64* %35
store i32 1, i32* %14
br label %486
486: ; preds = %548, %477
%487 = load i32, i32* %14
%488 = sitofp i32 %487 to double
%489 = load double, double* %18
%490 = fcmp olt double %488, %489
br i1 %490, label %491, label %551
491: ; preds = %486
%492 = load double*, double** %7
%493 = load i32, i32* %8
%494 = load i32, i32* %9
%495 = load i32, i32* %14
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds double, double* %90, i64 %496
%498 = load double, double* %497
%499 = call double @deriv2(double* %492, i32 %493, i32 %494, double %498)
%500 = load i32, i32* %14
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds double, double* %482, i64 %501
store double %499, double* %502
%503 = load double*, double** %7
%504 = load i32, i32* %8
%505 = load i32, i32* %9
%506 = load i32, i32* %14
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds double, double* %98, i64 %507
%509 = load double, double* %508
%510 = call double @deriv2(double* %503, i32 %504, i32 %505, double %509)
%511 = load i32, i32* %14
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds double, double* %485, i64 %512
store double %510, double* %513
%514 = load i32, i32* %14
%515 = sext i32 %514 to i64
%516 = getelementptr inbounds double, double* %482, i64 %515
%517 = load double, double* %516
%518 = load i32, i32* %14
%519 = sext i32 %518 to i64
%520 = getelementptr inbounds double, double* %485, i64 %519
%521 = load double, double* %520
%522 = fsub double %517, %521
%523 = call double @abs(double %522)
%524 = load double, double* %15
%525 = fmul double %524, 1.000000e+03
%526 = fcmp ogt double %523, %525
br i1 %526, label %541, label %527
527: ; preds = %491
%528 = load i32, i32* %14
%529 = sext i32 %528 to i64
%530 = getelementptr inbounds double, double* %482, i64 %529
%531 = load double, double* %530
%532 = load i32, i32* %14
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds double, double* %425, i64 %533
%535 = load double, double* %534
%536 = fsub double %531, %535
%537 = call double @abs(double %536)
%538 = load double, double* %15
%539 = fmul double %538, 1.000000e+03
%540 = fcmp ogt double %537, %539
br i1 %540, label %541, label %547
541: ; preds = %527, %491
%542 = load i32, i32* @stdout
%543 = call i32 @fprintf(i32 %542, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%544 = load i32, i32* @stderr
%545 = call i32 @fprintf(i32 %544, i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.16, i64 0, i64 0))
%546 = call i32 @sleep(i32 3)
store i32 7, i32* %6
store i32 1, i32* %26
br label %651
547: ; preds = %527
br label %548
548: ; preds = %547
%549 = load i32, i32* %14
%550 = add nsw i32 %549, 1
store i32 %550, i32* %14
br label %486
551: ; preds = %486
%552 = load i32, i32* @stdout
%553 = call i32 @fprintf(i32 %552, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%554 = load i32, i32* %9
%555 = icmp eq i32 %554, 1
br i1 %555, label %556, label %560
556: ; preds = %551
%557 = load i32, i32* %8
%558 = icmp slt i32 %557, 4
br i1 %558, label %559, label %560
559: ; preds = %556
store i32 8, i32* %6
store i32 1, i32* %26
br label %651
560: ; preds = %556, %551
%561 = load i32, i32* @stdout
%562 = call i32 @fprintf(i32 %561, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.17, i64 0, i64 0))
%563 = load i32, i32* %17
%564 = zext i32 %563 to i64
%565 = alloca double, i64 %564
store i64 %564, i64* %36
%566 = load i32, i32* %17
%567 = zext i32 %566 to i64
%568 = alloca double, i64 %567
store i64 %567, i64* %37
%569 = load i32, i32* %17
%570 = zext i32 %569 to i64
%571 = alloca double, i64 %570
store i64 %570, i64* %38
store i32 1, i32* %14
br label %572
572: ; preds = %645, %560
%573 = load i32, i32* %14
%574 = sitofp i32 %573 to double
%575 = load double, double* %18
%576 = fcmp olt double %574, %575
br i1 %576, label %577, label %648
577: ; preds = %572
%578 = load double*, double** %7
%579 = load i32, i32* %8
%580 = load i32, i32* %9
%581 = load i32, i32* %14
%582 = sext i32 %581 to i64
%583 = getelementptr inbounds double, double* %90, i64 %582
%584 = load double, double* %583
%585 = call double @deriv4(double* %578, i32 %579, i32 %580, double %584)
%586 = load i32, i32* %14
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds double, double* %565, i64 %587
store double %585, double* %588
%589 = load double*, double** %7
%590 = load i32, i32* %8
%591 = load i32, i32* %9
%592 = load i32, i32* %14
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds double, double* %98, i64 %593
%595 = load double, double* %594
%596 = call double @deriv4(double* %589, i32 %590, i32 %591, double %595)
%597 = load i32, i32* %14
%598 = sext i32 %597 to i64
%599 = getelementptr inbounds double, double* %568, i64 %598
store double %596, double* %599
%600 = load double*, double** %7
%601 = load i32, i32* %8
%602 = load i32, i32* %9
%603 = load i32, i32* %14
%604 = sext i32 %603 to i64
%605 = getelementptr inbounds double, double* %98, i64 %604
%606 = load double, double* %605
%607 = call double @deriv4(double* %600, i32 %601, i32 %602, double %606)
%608 = load i32, i32* %14
%609 = sext i32 %608 to i64
%610 = getelementptr inbounds double, double* %571, i64 %609
store double %607, double* %610
%611 = load i32, i32* %14
%612 = sext i32 %611 to i64
%613 = getelementptr inbounds double, double* %565, i64 %612
%614 = load double, double* %613
%615 = load i32, i32* %14
%616 = sext i32 %615 to i64
%617 = getelementptr inbounds double, double* %568, i64 %616
%618 = load double, double* %617
%619 = fsub double %614, %618
%620 = call double @abs(double %619)
%621 = load double, double* %15
%622 = fmul double %621, 1.000000e+03
%623 = fcmp ogt double %620, %622
br i1 %623, label %638, label %624
624: ; preds = %577
%625 = load i32, i32* %14
%626 = sext i32 %625 to i64
%627 = getelementptr inbounds double, double* %565, i64 %626
%628 = load double, double* %627
%629 = load i32, i32* %14
%630 = sext i32 %629 to i64
%631 = getelementptr inbounds double, double* %571, i64 %630
%632 = load double, double* %631
%633 = fsub double %628, %632
%634 = call double @abs(double %633)
%635 = load double, double* %15
%636 = fmul double %635, 1.000000e+03
%637 = fcmp ogt double %634, %636
br i1 %637, label %638, label %644
638: ; preds = %624, %577
%639 = load i32, i32* @stdout
%640 = call i32 @fprintf(i32 %639, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%641 = load i32, i32* @stderr
%642 = call i32 @fprintf(i32 %641, i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.18, i64 0, i64 0))
%643 = call i32 @sleep(i32 3)
store i32 8, i32* %6
store i32 1, i32* %26
br label %651
644: ; preds = %624
br label %645
645: ; preds = %644
%646 = load i32, i32* %14
%647 = add nsw i32 %646, 1
store i32 %647, i32* %14
br label %572
648: ; preds = %572
%649 = load i32, i32* @stdout
%650 = call i32 @fprintf(i32 %649, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
store i32 9, i32* %6
store i32 1, i32* %26
br label %651
651: ; preds = %648, %638, %559, %541, %476, %458, %406, %330, %280, %218
%652 = load i8*, i8** %19
br label %653
653: ; preds = %651, %56
%654 = load i32, i32* %6
ret i32 %654
}

LLVM IR (-O2):
@.str = [6 x i8] c"clear\00"
@stdout = global i32 0
@.str.1 = [43 x i8] c"[*] Discord Images Of The Extremous Points\00"
@.str.2 = [3 x i8] c" \0A\00"
@stderr = global i32 0
@.str.3 = [65 x i8] c"error: The Images Of The Extremous Points Should Be Discord !!!\0A\00"
@.str.4 = [8 x i8] c" OK \0A\00"
@.str.5 = [26 x i8] c"[*] Function Continuous? \00"
@.str.6 = [52 x i8] c"error: Function Not Continuous In The Interval !!!\0A\00"
@.str.7 = [16 x i8] c"[*] Derivable? \00"
@.str.8 = [51 x i8] c"error: Function Not Derivable In The Interval !!!\0A\00"
@.str.9 = [24 x i8] c"[*] Function Monotone? \00"
@.str.10 = [50 x i8] c"error: Function Not Monotone In The Interval !!!\0A\00"
@.str.11 = [32 x i8] c"[*] First Derivate Continuous? \00"
@.str.12 = [58 x i8] c"error: First Derivate Not Continuous In The Interval !!!\0A\00"
@.str.13 = [30 x i8] c"[*] First Derivate Monotone? \00"
@.str.14 = [66 x i8] c"error: Second Derivate's Sign Not Continuous In The Interval !!!\0A\00"
@.str.15 = [33 x i8] c"[*] Second Derivate Continuous? \00"
@.str.16 = [59 x i8] c"error: Second Derivate Not Continuous In The Interval !!!\0A\00"
@.str.17 = [33 x i8] c"[*] Fourth Continuous Derivate? \00"
@.str.18 = [59 x i8] c"error: Fourth Derivate Not Continuous In The Interval !!!\0A\00"
define i32 @convergence(double* %0, i32 %1, i32 %2, double %3, double %4) {
%6 = tail call i32 @system(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
%7 = load i32, i32* @stdout
%8 = tail call i32 @fprintf(i32 %7, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.1, i64 0, i64 0))
%9 = tail call double @function(double* %0, i32 %1, i32 %2, double %3)
%10 = tail call double @function(double* %0, i32 %1, i32 %2, double %4)
%11 = fmul double %9, %10
%12 = fcmp ogt double %11, 0.000000e+00
br i1 %12, label %13, label %19
13: ; preds = %5
%14 = load i32, i32* @stdout
%15 = tail call i32 @fprintf(i32 %14, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%16 = load i32, i32* @stderr
%17 = tail call i32 @fprintf(i32 %16, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.3, i64 0, i64 0))
%18 = tail call i32 @sleep(i32 3)
br label %289
19: ; preds = %5
%20 = fcmp olt double %11, 0.000000e+00
br i1 %20, label %21, label %24
21: ; preds = %19
%22 = load i32, i32* @stdout
%23 = tail call i32 @fprintf(i32 %22, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
br label %24
24: ; preds = %21, %19
%25 = fsub double %4, %3
%26 = tail call double @abs(double %25)
%27 = fmul double %26, 1.000000e+03
%28 = fptosi double %27 to i32
%29 = zext i32 %28 to i64
%30 = tail call i8* @llvm.stacksave()
%31 = alloca double, i64 %29
%32 = fadd double %3, 1.000000e-03
store double %32, double* %31
%33 = fadd double %4, -1.000000e-03
%34 = fmul double %33, 1.000000e+03
%35 = alloca double, i64 %29
%36 = fadd double %32, 1.000000e-08
store double %36, double* %35
%37 = alloca double, i64 %29
%38 = fadd double %32, -1.000000e-08
store double %38, double* %37
%39 = fcmp ogt double %34, 1.000000e+00
br i1 %39, label %43, label %40
40: ; preds = %24
%41 = load i32, i32* @stdout
%42 = tail call i32 @fprintf(i32 %41, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.5, i64 0, i64 0))
br label %88
43: ; preds = %24, %43
%44 = phi double [ %46, %43 ], [ %32, %24 ]
%45 = phi i64 [ %52, %43 ], [ 1, %24 ]
%46 = fadd double %44, 1.000000e-03
%47 = getelementptr inbounds double, double* %31, i64 %45
store double %46, double* %47
%48 = fadd double %46, 1.000000e-08
%49 = getelementptr inbounds double, double* %35, i64 %45
store double %48, double* %49
%50 = fadd double %46, -1.000000e-08
%51 = getelementptr inbounds double, double* %37, i64 %45
store double %50, double* %51
%52 = add nuw i64 %45, 1
%53 = trunc i64 %52 to i32
%54 = sitofp i32 %53 to double
%55 = fcmp ogt double %34, %54
br i1 %55, label %43, label %56
56: ; preds = %43
%57 = load i32, i32* @stdout
%58 = tail call i32 @fprintf(i32 %57, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.5, i64 0, i64 0))
br i1 %39, label %63, label %115
59: ; preds = %77
%60 = trunc i64 %81 to i32
%61 = sitofp i32 %60 to double
%62 = fcmp ogt double %34, %61
br i1 %62, label %63, label %88
63: ; preds = %56, %59
%64 = phi i64 [ %81, %59 ], [ 1, %56 ]
%65 = getelementptr inbounds double, double* %35, i64 %64
%66 = load double, double* %65
%67 = tail call double @function(double* %0, i32 %1, i32 %2, double %66)
%68 = getelementptr inbounds double, double* %37, i64 %64
%69 = load double, double* %68
%70 = tail call double @function(double* %0, i32 %1, i32 %2, double %69)
%71 = getelementptr inbounds double, double* %31, i64 %64
%72 = load double, double* %71
%73 = tail call double @function(double* %0, i32 %1, i32 %2, double %72)
%74 = fsub double %67, %70
%75 = tail call double @abs(double %74)
%76 = fcmp ogt double %75, 1.000000e-04
br i1 %76, label %82, label %77
77: ; preds = %63
%78 = fsub double %67, %73
%79 = tail call double @abs(double %78)
%80 = fcmp ogt double %79, 1.000000e-04
%81 = add nuw i64 %64, 1
br i1 %80, label %82, label %59
82: ; preds = %77, %63
%83 = load i32, i32* @stdout
%84 = tail call i32 @fprintf(i32 %83, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%85 = load i32, i32* @stderr
%86 = tail call i32 @fprintf(i32 %85, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.6, i64 0, i64 0))
%87 = tail call i32 @sleep(i32 3)
br label %287
88: ; preds = %59, %40
%89 = load i32, i32* @stdout
%90 = tail call i32 @fprintf(i32 %89, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%91 = load i32, i32* @stdout
%92 = tail call i32 @fprintf(i32 %91, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.7, i64 0, i64 0))
br i1 %39, label %97, label %120
93: ; preds = %97
%94 = trunc i64 %108 to i32
%95 = sitofp i32 %94 to double
%96 = fcmp ogt double %34, %95
br i1 %96, label %97, label %120
97: ; preds = %88, %93
%98 = phi i64 [ %108, %93 ], [ 1, %88 ]
%99 = getelementptr inbounds double, double* %35, i64 %98
%100 = load double, double* %99
%101 = tail call double @deriv1(double* %0, i32 %1, i32 %2, double %100)
%102 = getelementptr inbounds double, double* %37, i64 %98
%103 = load double, double* %102
%104 = tail call double @deriv1(double* %0, i32 %1, i32 %2, double %103)
%105 = fsub double %101, %104
%106 = tail call double @abs(double %105)
%107 = fcmp ogt double %106, 1.000000e-05
%108 = add nuw i64 %98, 1
br i1 %107, label %109, label %93
109: ; preds = %97
%110 = load i32, i32* @stdout
%111 = tail call i32 @fprintf(i32 %110, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%112 = load i32, i32* @stderr
%113 = tail call i32 @fprintf(i32 %112, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.8, i64 0, i64 0))
%114 = tail call i32 @sleep(i32 3)
br label %287
115: ; preds = %56
%116 = load i32, i32* @stdout
%117 = tail call i32 @fprintf(i32 %116, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%118 = load i32, i32* @stdout
%119 = tail call i32 @fprintf(i32 %118, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.7, i64 0, i64 0))
br label %120
120: ; preds = %93, %115, %88
%121 = load i32, i32* @stdout
%122 = tail call i32 @fprintf(i32 %121, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%123 = load i32, i32* @stdout
%124 = tail call i32 @fprintf(i32 %123, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.9, i64 0, i64 0))
%125 = alloca double, i64 %29
%126 = tail call double @deriv1(double* %0, i32 %1, i32 %2, double %32)
store double %126, double* %125
br i1 %39, label %131, label %179
127: ; preds = %131
%128 = trunc i64 %139 to i32
%129 = sitofp i32 %128 to double
%130 = fcmp ogt double %34, %129
br i1 %130, label %131, label %146
131: ; preds = %120, %127
%132 = phi i64 [ %139, %127 ], [ 1, %120 ]
%133 = getelementptr inbounds double, double* %31, i64 %132
%134 = load double, double* %133
%135 = tail call double @deriv1(double* %0, i32 %1, i32 %2, double %134)
%136 = getelementptr inbounds double, double* %125, i64 %132
store double %135, double* %136
%137 = fmul double %126, %135
%138 = fcmp olt double %137, 0.000000e+00
%139 = add nuw i64 %132, 1
br i1 %138, label %140, label %127
140: ; preds = %131
%141 = load i32, i32* @stdout
%142 = tail call i32 @fprintf(i32 %141, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%143 = load i32, i32* @stderr
%144 = tail call i32 @fprintf(i32 %143, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.10, i64 0, i64 0))
%145 = tail call i32 @sleep(i32 3)
br label %287
146: ; preds = %127
%147 = load i32, i32* @stdout
%148 = tail call i32 @fprintf(i32 %147, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%149 = load i32, i32* @stdout
%150 = tail call i32 @fprintf(i32 %149, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.11, i64 0, i64 0))
br i1 %39, label %155, label %184
151: ; preds = %166
%152 = trunc i64 %172 to i32
%153 = sitofp i32 %152 to double
%154 = fcmp ogt double %34, %153
br i1 %154, label %155, label %184
155: ; preds = %146, %151
%156 = phi i64 [ %172, %151 ], [ 1, %146 ]
%157 = getelementptr inbounds double, double* %35, i64 %156
%158 = load double, double* %157
%159 = tail call double @deriv1(double* %0, i32 %1, i32 %2, double %158)
%160 = getelementptr inbounds double, double* %37, i64 %156
%161 = load double, double* %160
%162 = tail call double @deriv1(double* %0, i32 %1, i32 %2, double %161)
%163 = fsub double %159, %162
%164 = tail call double @abs(double %163)
%165 = fcmp ogt double %164, 1.000000e-05
br i1 %165, label %173, label %166
166: ; preds = %155
%167 = getelementptr inbounds double, double* %125, i64 %156
%168 = load double, double* %167
%169 = fsub double %159, %168
%170 = tail call double @abs(double %169)
%171 = fcmp ogt double %170, 1.000000e-05
%172 = add nuw i64 %156, 1
br i1 %171, label %173, label %151
173: ; preds = %166, %155
%174 = load i32, i32* @stdout
%175 = tail call i32 @fprintf(i32 %174, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%176 = load i32, i32* @stderr
%177 = tail call i32 @fprintf(i32 %176, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.12, i64 0, i64 0))
%178 = tail call i32 @sleep(i32 3)
br label %287
179: ; preds = %120
%180 = load i32, i32* @stdout
%181 = tail call i32 @fprintf(i32 %180, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%182 = load i32, i32* @stdout
%183 = tail call i32 @fprintf(i32 %182, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.11, i64 0, i64 0))
br label %184
184: ; preds = %151, %179, %146
%185 = load i32, i32* @stdout
%186 = tail call i32 @fprintf(i32 %185, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%187 = load i32, i32* @stdout
%188 = tail call i32 @fprintf(i32 %187, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.13, i64 0, i64 0))
%189 = add nsw i32 %28, -2
%190 = zext i32 %189 to i64
%191 = alloca double, i64 %190
%192 = tail call double @deriv2(double* %0, i32 %1, i32 %2, double %126)
store double %192, double* %191
br i1 %39, label %197, label %212
193: ; preds = %197
%194 = trunc i64 %205 to i32
%195 = sitofp i32 %194 to double
%196 = fcmp ogt double %34, %195
br i1 %196, label %197, label %212
197: ; preds = %184, %193
%198 = phi i64 [ %205, %193 ], [ 1, %184 ]
%199 = getelementptr inbounds double, double* %125, i64 %198
%200 = load double, double* %199
%201 = tail call double @deriv2(double* %0, i32 %1, i32 %2, double %200)
%202 = getelementptr inbounds double, double* %191, i64 %198
store double %201, double* %202
%203 = fmul double %192, %201
%204 = fcmp olt double %203, 0.000000e+00
%205 = add nuw i64 %198, 1
br i1 %204, label %206, label %193
206: ; preds = %197
%207 = load i32, i32* @stdout
%208 = tail call i32 @fprintf(i32 %207, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%209 = load i32, i32* @stderr
%210 = tail call i32 @fprintf(i32 %209, i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.14, i64 0, i64 0))
%211 = tail call i32 @sleep(i32 3)
br label %287
212: ; preds = %193, %184
%213 = load i32, i32* @stdout
%214 = tail call i32 @fprintf(i32 %213, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%215 = icmp eq i32 %2, 1
%216 = icmp slt i32 %1, 2
%217 = and i1 %216, %215
br i1 %217, label %287, label %218
218: ; preds = %212
%219 = load i32, i32* @stdout
%220 = tail call i32 @fprintf(i32 %219, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.15, i64 0, i64 0))
br i1 %39, label %225, label %249
221: ; preds = %236
%222 = trunc i64 %242 to i32
%223 = sitofp i32 %222 to double
%224 = fcmp ogt double %34, %223
br i1 %224, label %225, label %249
225: ; preds = %218, %221
%226 = phi i64 [ %242, %221 ], [ 1, %218 ]
%227 = getelementptr inbounds double, double* %35, i64 %226
%228 = load double, double* %227
%229 = tail call double @deriv2(double* %0, i32 %1, i32 %2, double %228)
%230 = getelementptr inbounds double, double* %37, i64 %226
%231 = load double, double* %230
%232 = tail call double @deriv2(double* %0, i32 %1, i32 %2, double %231)
%233 = fsub double %229, %232
%234 = tail call double @abs(double %233)
%235 = fcmp ogt double %234, 1.000000e-05
br i1 %235, label %243, label %236
236: ; preds = %225
%237 = getelementptr inbounds double, double* %191, i64 %226
%238 = load double, double* %237
%239 = fsub double %229, %238
%240 = tail call double @abs(double %239)
%241 = fcmp ogt double %240, 1.000000e-05
%242 = add nuw i64 %226, 1
br i1 %241, label %243, label %221
243: ; preds = %236, %225
%244 = load i32, i32* @stdout
%245 = tail call i32 @fprintf(i32 %244, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%246 = load i32, i32* @stderr
%247 = tail call i32 @fprintf(i32 %246, i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.16, i64 0, i64 0))
%248 = tail call i32 @sleep(i32 3)
br label %287
249: ; preds = %221, %218
%250 = load i32, i32* @stdout
%251 = tail call i32 @fprintf(i32 %250, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%252 = icmp slt i32 %1, 4
%253 = and i1 %252, %215
br i1 %253, label %287, label %254
254: ; preds = %249
%255 = load i32, i32* @stdout
%256 = tail call i32 @fprintf(i32 %255, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.17, i64 0, i64 0))
br i1 %39, label %261, label %284
257: ; preds = %273
%258 = trunc i64 %277 to i32
%259 = sitofp i32 %258 to double
%260 = fcmp ogt double %34, %259
br i1 %260, label %261, label %284
261: ; preds = %254, %257
%262 = phi i64 [ %277, %257 ], [ 1, %254 ]
%263 = getelementptr inbounds double, double* %35, i64 %262
%264 = load double, double* %263
%265 = tail call double @deriv4(double* %0, i32 %1, i32 %2, double %264)
%266 = getelementptr inbounds double, double* %37, i64 %262
%267 = load double, double* %266
%268 = tail call double @deriv4(double* %0, i32 %1, i32 %2, double %267)
%269 = tail call double @deriv4(double* %0, i32 %1, i32 %2, double %267)
%270 = fsub double %265, %268
%271 = tail call double @abs(double %270)
%272 = fcmp ogt double %271, 1.000000e-05
br i1 %272, label %278, label %273
273: ; preds = %261
%274 = fsub double %265, %269
%275 = tail call double @abs(double %274)
%276 = fcmp ogt double %275, 1.000000e-05
%277 = add nuw i64 %262, 1
br i1 %276, label %278, label %257
278: ; preds = %273, %261
%279 = load i32, i32* @stdout
%280 = tail call i32 @fprintf(i32 %279, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%281 = load i32, i32* @stderr
%282 = tail call i32 @fprintf(i32 %281, i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.18, i64 0, i64 0))
%283 = tail call i32 @sleep(i32 3)
br label %287
284: ; preds = %257, %254
%285 = load i32, i32* @stdout
%286 = tail call i32 @fprintf(i32 %285, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
br label %287
287: ; preds = %206, %243, %278, %284, %212, %249, %173, %140, %109, %82
%288 = phi i32 [ 2, %82 ], [ 3, %109 ], [ 4, %140 ], [ 5, %173 ], [ 6, %206 ], [ 7, %243 ], [ 8, %278 ], [ 9, %284 ], [ 7, %212 ], [ 8, %249 ]
tail call void @llvm.stackrestore(i8* %30)
br label %289
289: ; preds = %287, %13
%290 = phi i32 [ 1, %13 ], [ %288, %287 ]
ret i32 %290
}