#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 */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ Weights_init(double *);
int /*<<< orphan*/ export_weights(double *, double *, double *);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, int, double);
int /*<<< orphan*/ fscanf(int /*<<< orphan*/ *, char *, double *, double *,
                          double *, double *, double *, double *, double *,
                          double *, double *);
int log(int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ reset_parameters(double *, double *, double *);
double sigmoid(double);
int main() {
  double train_data[600][8];
  double train_label[600];
  double predicted_Train_label[600];
  double weights[8];
  double bias[600] = {1.0};
  double test_data[168][8];
  double test_label[168];
  double predicted_Test_label[168];
  double z[600] = {0.0};
  double a[600] = {0.0};
  double gradient[600];
  double train_features_average[8];
  double test_features_average[8];
  int row, column = 0;
  FILE *fp;
  fp = fopen("pima-indians-diabetes.txt", "r");
  if (fp != NULL) {
    for (row = 0; row < 600; row++) {
      fscanf(fp, "%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf\n",
             &train_data[row][column], &train_data[row][column + 1],
             &train_data[row][column + 2], &train_data[row][column + 3],
             &train_data[row][column + 4], &train_data[row][column + 5],
             &train_data[row][column + 6], &train_data[row][column + 7],
             &train_label[row]);
    }
    fclose(fp);
  } else {
    printf("File Can not be opened !");
  }
  fp = fopen("pima-indians-diabetes_test.txt", "r");
  column = 0;
  if (fp != NULL) {
    for (row = 0; row < 168; row++) {
      fscanf(fp, "%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf\n",
             &test_data[row][column], &test_data[row][column + 1],
             &test_data[row][column + 2], &test_data[row][column + 3],
             &test_data[row][column + 4], &test_data[row][column + 5],
             &test_data[row][column + 6], &test_data[row][column + 7],
             &test_label[row]);
    }
    fclose(fp);
  } else {
    printf("File Can not be opened !");
  }
  int j, i;
  for (i = 0; i < 8; i++) {
    double average = 0;
    for (j = 0; j < 600; j++) {
      average += train_data[j][i];
    }
    average = (double)(average / 600);
    train_features_average[i] = average;
  }
  for (i = 0; i < 8; i++) {
    for (j = 0; j < 600; j++) {
      train_data[j][i] = ((train_data[j][i] - train_features_average[i]) / 600);
    }
  }
  for (i = 0; i < 8; i++) {
    double average = 0;
    for (j = 0; j < 168; j++) {
      average += test_data[j][i];
    }
    average = (double)(average / 168);
    test_features_average[i] = average;
  }
  for (i = 0; i < 8; i++) {
    for (j = 0; j < 168; j++) {
      test_data[j][i] = ((test_data[j][i] - test_features_average[i]) / 168);
    }
  }
  Weights_init(weights);
  FILE *cost_report_fp;
  cost_report_fp = fopen("Cost_report.txt", "a");
  int iteration;
  double cost = 0;
  for (iteration = 0; iteration < 4000; iteration++) {
    cost = 0;
    reset_parameters(z, a, gradient);
    int i = 0, j = 0;
    for (i = 0; i < 600; i++) {
      for (j = 0; j < 8; j++) {
        z[i] += weights[j] * train_data[i][j];
      }
      z[i] += bias[i];
      a[i] = sigmoid(z[i]);
    }
    for (j = 0; j < 600; j++) {
      cost +=
          -(train_label[j] * log(a[j]) + (1 - train_label[j]) * log(1 - a[j]));
    }
    cost = (double)cost / 600;
    if (iteration % 1000 == 0) {
      printf("iteration:%d --------------> cost: %lf \n", iteration, cost);
    }
    fprintf(cost_report_fp, "iteration:%d --------------> cost: %lf \n",
            iteration, cost);
    for (j = 0; j < 600; j++) {
      gradient[j] = a[j] - train_label[j];
    }
    for (i = 0; i < 8; i++) {
      double results[600] = {0}, sum = 0, gradient_sum = 0;
      for (j = 0; j < 600; j++) {
        results[j] = gradient[j] * train_data[j][i];
        gradient_sum += gradient[j];
      }
      for (j = 0; j < 600; j++) {
        sum += results[j];
      }
      weights[i] -= (double)(0.01 * sum / 600);
      for (j = 0; j < 600; j++) {
        bias[j] -= (double)(0.01 * gradient_sum / 600);
      }
    }
  }
  reset_parameters(z, a, gradient);
  for (i = 0; i < 168; i++) {
    for (j = 0; j < 8; j++) {
      z[i] += weights[j] * test_data[i][j];
    }
    z[i] += bias[i];
    predicted_Test_label[i] = sigmoid(z[i]);
  }
  double counter = 0;
  for (i = 0; i < 168; i++) {
    if (predicted_Test_label[i] > 0.5)
      predicted_Test_label[i] = 1;
    else if (predicted_Test_label[i] < 0.5)
      predicted_Test_label[i] = 0;
    if (predicted_Test_label[i] == test_label[i])
      counter++;
    printf("actual: [%lf] ,predicted: [%lf].\n", test_label[i],
           predicted_Test_label[i]);
  }
  double accuracy = (counter / 168) * 100;
  printf("\n\n\n  Test Accuracy is: %lf ", accuracy);
  export_weights(weights, bias, test_features_average);
  fclose(cost_report_fp);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
sub    $0x14f40,%rsp
movl   $0x0,-0x14(%rbp)
lea    -0xcea0(%rbp),%rdi
xor    %esi,%esi
mov    $0x12c0,%edx
call   1070 <memset@plt>
movsd  0x1e20(%rip),%xmm0
movsd  %xmm0,-0xcea0(%rbp)
ff
lea    -0x115e0(%rbp),%rdi
xor    %esi,%esi
mov    $0x12c0,%edx
call   1070 <memset@plt>
lea    -0x128a0(%rbp),%rdi
xor    %esi,%esi
mov    $0x12c0,%edx
call   1070 <memset@plt>
movl   $0x0,-0x13be8(%rbp)
lea    0x1e11(%rip),%rdi
lea    0x1e24(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,-0x13bf0(%rbp)
cmpq   $0x0,-0x13bf0(%rbp)
je     13f3 <main+0x243>
movl   $0x0,-0x13be4(%rbp)
cmpl   $0x258,-0x13be4(%rbp)
jge    13e2 <main+0x232>
mov    -0x13bf0(%rbp),%rdi
movslq -0x13be4(%rbp),%rax
lea    -0x9620(%rbp),%rdx
shl    $0x6,%rax
add    %rax,%rdx
movslq -0x13be8(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdx
movslq -0x13be4(%rbp),%rax
lea    -0x9620(%rbp),%rcx
shl    $0x6,%rax
add    %rax,%rcx
mov    -0x13be8(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
add    %rax,%rcx
movslq -0x13be4(%rbp),%rax
lea    -0x9620(%rbp),%r8
shl    $0x6,%rax
add    %rax,%r8
mov    -0x13be8(%rbp),%eax
add    $0x2,%eax
cltq
shl    $0x3,%rax
add    %rax,%r8
movslq -0x13be4(%rbp),%rax
lea    -0x9620(%rbp),%r9
shl    $0x6,%rax
add    %rax,%r9
mov    -0x13be8(%rbp),%eax
add    $0x3,%eax
cltq
shl    $0x3,%rax
add    %rax,%r9
movslq -0x13be4(%rbp),%rax
lea    -0x9620(%rbp),%r14
shl    $0x6,%rax
add    %rax,%r14
mov    -0x13be8(%rbp),%eax
add    $0x4,%eax
cltq
shl    $0x3,%rax
add    %rax,%r14
movslq -0x13be4(%rbp),%rax
lea    -0x9620(%rbp),%rbx
shl    $0x6,%rax
add    %rax,%rbx
mov    -0x13be8(%rbp),%eax
add    $0x5,%eax
cltq
shl    $0x3,%rax
add    %rax,%rbx
movslq -0x13be4(%rbp),%rax
lea    -0x9620(%rbp),%r11
shl    $0x6,%rax
add    %rax,%r11
mov    -0x13be8(%rbp),%eax
add    $0x6,%eax
cltq
shl    $0x3,%rax
add    %rax,%r11
movslq -0x13be4(%rbp),%rax
lea    -0x9620(%rbp),%r10
shl    $0x6,%rax
add    %rax,%r10
mov    -0x13be8(%rbp),%eax
add    $0x7,%eax
cltq
shl    $0x3,%rax
add    %rax,%r10
movslq -0x13be4(%rbp),%rsi
lea    -0xa8e0(%rbp),%rax
shl    $0x3,%rsi
add    %rsi,%rax
lea    0x1c9b(%rip),%rsi
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1080 <fscanf@plt>
mov    -0x13be4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13be4(%rbp)
jmp    124a <main+0x9a>
mov    -0x13bf0(%rbp),%rdi
call   1040 <fclose@plt>
jmp    1401 <main+0x251>
lea    0x1c77(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1c82(%rip),%rdi
lea    0x1c3b(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,-0x13bf0(%rbp)
movl   $0x0,-0x13be8(%rbp)
cmpq   $0x0,-0x13bf0(%rbp)
je     15e6 <main+0x436>
movl   $0x0,-0x13be4(%rbp)
cmpl   $0xa8,-0x13be4(%rbp)
jge    15d5 <main+0x425>
mov    -0x13bf0(%rbp),%rdi
movslq -0x13be4(%rbp),%rax
lea    -0xf8a0(%rbp),%rdx
shl    $0x6,%rax
add    %rax,%rdx
movslq -0x13be8(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdx
movslq -0x13be4(%rbp),%rax
lea    -0xf8a0(%rbp),%rcx
shl    $0x6,%rax
add    %rax,%rcx
mov    -0x13be8(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
add    %rax,%rcx
movslq -0x13be4(%rbp),%rax
lea    -0xf8a0(%rbp),%r8
shl    $0x6,%rax
add    %rax,%r8
mov    -0x13be8(%rbp),%eax
add    $0x2,%eax
cltq
shl    $0x3,%rax
add    %rax,%r8
movslq -0x13be4(%rbp),%rax
lea    -0xf8a0(%rbp),%r9
shl    $0x6,%rax
add    %rax,%r9
mov    -0x13be8(%rbp),%eax
add    $0x3,%eax
cltq
shl    $0x3,%rax
add    %rax,%r9
movslq -0x13be4(%rbp),%rax
lea    -0xf8a0(%rbp),%r14
shl    $0x6,%rax
add    %rax,%r14
mov    -0x13be8(%rbp),%eax
add    $0x4,%eax
cltq
shl    $0x3,%rax
add    %rax,%r14
movslq -0x13be4(%rbp),%rax
lea    -0xf8a0(%rbp),%rbx
shl    $0x6,%rax
add    %rax,%rbx
mov    -0x13be8(%rbp),%eax
add    $0x5,%eax
cltq
shl    $0x3,%rax
add    %rax,%rbx
movslq -0x13be4(%rbp),%rax
lea    -0xf8a0(%rbp),%r11
shl    $0x6,%rax
add    %rax,%r11
mov    -0x13be8(%rbp),%eax
add    $0x6,%eax
cltq
shl    $0x3,%rax
add    %rax,%r11
movslq -0x13be4(%rbp),%rax
lea    -0xf8a0(%rbp),%r10
shl    $0x6,%rax
add    %rax,%r10
mov    -0x13be8(%rbp),%eax
add    $0x7,%eax
cltq
shl    $0x3,%rax
add    %rax,%r10
movslq -0x13be4(%rbp),%rsi
lea    -0xfde0(%rbp),%rax
shl    $0x3,%rsi
add    %rsi,%rax
lea    0x1aa8(%rip),%rsi
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1080 <fscanf@plt>
mov    -0x13be4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13be4(%rbp)
jmp    143d <main+0x28d>
mov    -0x13bf0(%rbp),%rdi
call   1040 <fclose@plt>
jmp    15f4 <main+0x444>
lea    0x1a84(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x13bf8(%rbp)
cmpl   $0x8,-0x13bf8(%rbp)
jge    16bd <main+0x50d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x13c00(%rbp)
ff
movl   $0x0,-0x13bf4(%rbp)
cmpl   $0x258,-0x13bf4(%rbp)
jge    1675 <main+0x4c5>
movslq -0x13bf4(%rbp),%rcx
lea    -0x9620(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x13bf8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x13c00(%rbp),%xmm0
ff
movsd  %xmm0,-0x13c00(%rbp)
ff
mov    -0x13bf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13bf4(%rbp)
jmp    1620 <main+0x470>
movsd  -0x13c00(%rbp),%xmm0
ff
movsd  0x199b(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x13c00(%rbp)
ff
movsd  -0x13c00(%rbp),%xmm0
ff
movslq -0x13bf8(%rbp),%rax
movsd  %xmm0,-0x13ba0(%rbp,%rax,8)
fe ff
mov    -0x13bf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13bf8(%rbp)
jmp    15fe <main+0x44e>
movl   $0x0,-0x13bf8(%rbp)
cmpl   $0x8,-0x13bf8(%rbp)
jge    1779 <main+0x5c9>
movl   $0x0,-0x13bf4(%rbp)
cmpl   $0x258,-0x13bf4(%rbp)
jge    1760 <main+0x5b0>
movslq -0x13bf4(%rbp),%rcx
lea    -0x9620(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x13bf8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x13bf8(%rbp),%rax
subsd  -0x13ba0(%rbp,%rax,8),%xmm0
fe ff
movsd  0x18f9(%rip),%xmm1
divsd  %xmm1,%xmm0
movslq -0x13bf4(%rbp),%rcx
lea    -0x9620(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x13bf8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x13bf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13bf4(%rbp)
jmp    16de <main+0x52e>
jmp    1765 <main+0x5b5>
mov    -0x13bf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13bf8(%rbp)
jmp    16c7 <main+0x517>
movl   $0x0,-0x13bf8(%rbp)
cmpl   $0x8,-0x13bf8(%rbp)
jge    1842 <main+0x692>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x13c08(%rbp)
ff
movl   $0x0,-0x13bf4(%rbp)
cmpl   $0xa8,-0x13bf4(%rbp)
jge    17fa <main+0x64a>
movslq -0x13bf4(%rbp),%rcx
lea    -0xf8a0(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x13bf8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x13c08(%rbp),%xmm0
ff
movsd  %xmm0,-0x13c08(%rbp)
ff
mov    -0x13bf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13bf4(%rbp)
jmp    17a5 <main+0x5f5>
movsd  -0x13c08(%rbp),%xmm0
ff
movsd  0x1806(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x13c08(%rbp)
ff
movsd  -0x13c08(%rbp),%xmm0
ff
movslq -0x13bf8(%rbp),%rax
movsd  %xmm0,-0x13be0(%rbp,%rax,8)
fe ff
mov    -0x13bf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13bf8(%rbp)
jmp    1783 <main+0x5d3>
movl   $0x0,-0x13bf8(%rbp)
cmpl   $0x8,-0x13bf8(%rbp)
jge    18fe <main+0x74e>
movl   $0x0,-0x13bf4(%rbp)
cmpl   $0xa8,-0x13bf4(%rbp)
jge    18e5 <main+0x735>
movslq -0x13bf4(%rbp),%rcx
lea    -0xf8a0(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x13bf8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x13bf8(%rbp),%rax
subsd  -0x13be0(%rbp,%rax,8),%xmm0
fe ff
movsd  0x1764(%rip),%xmm1
divsd  %xmm1,%xmm0
movslq -0x13bf4(%rbp),%rcx
lea    -0xf8a0(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x13bf8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x13bf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13bf4(%rbp)
jmp    1863 <main+0x6b3>
jmp    18ea <main+0x73a>
mov    -0x13bf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13bf8(%rbp)
jmp    184c <main+0x69c>
lea    -0xbbe0(%rbp),%rdi
call   10d0 <Weights_init@plt>
lea    0x1798(%rip),%rdi
lea    0x17a1(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,-0x13c10(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x13c20(%rbp)
ff
movl   $0x0,-0x13c14(%rbp)
cmpl   $0xfa0,-0x13c14(%rbp)
jge    1e2f <main+0xc7f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x13c20(%rbp)
ff
lea    -0x115e0(%rbp),%rdi
lea    -0x128a0(%rbp),%rsi
lea    -0x13b60(%rbp),%rdx
call   10a0 <reset_parameters@plt>
movl   $0x0,-0x13c24(%rbp)
movl   $0x0,-0x13c28(%rbp)
movl   $0x0,-0x13c24(%rbp)
cmpl   $0x258,-0x13c24(%rbp)
jge    1a7b <main+0x8cb>
movl   $0x0,-0x13c28(%rbp)
cmpl   $0x8,-0x13c28(%rbp)
jge    1a19 <main+0x869>
movslq -0x13c28(%rbp),%rax
movsd  -0xbbe0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x13c24(%rbp),%rcx
lea    -0x9620(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x13c28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x13c24(%rbp),%rax
movsd  -0x115e0(%rbp,%rax,8),%xmm1
fe ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x115e0(%rbp,%rax,8)
fe ff
mov    -0x13c28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c28(%rbp)
jmp    19a6 <main+0x7f6>
movslq -0x13c24(%rbp),%rax
movsd  -0xcea0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x13c24(%rbp),%rax
addsd  -0x115e0(%rbp,%rax,8),%xmm0
fe ff
movsd  %xmm0,-0x115e0(%rbp,%rax,8)
fe ff
movslq -0x13c24(%rbp),%rax
movsd  -0x115e0(%rbp,%rax,8),%xmm0
fe ff
call   1030 <sigmoid@plt>
movslq -0x13c24(%rbp),%rax
movsd  %xmm0,-0x128a0(%rbp,%rax,8)
fe ff
mov    -0x13c24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c24(%rbp)
jmp    198c <main+0x7dc>
movl   $0x0,-0x13c28(%rbp)
cmpl   $0x258,-0x13c28(%rbp)
jge    1b72 <main+0x9c2>
movslq -0x13c28(%rbp),%rax
movsd  -0xa8e0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x14f20(%rbp)
ff
movslq -0x13c28(%rbp),%rax
cvttsd2si -0x128a0(%rbp,%rax,8),%edi
fe ff
call   10b0 <log@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x14f18(%rbp)
ff
movslq -0x13c28(%rbp),%rax
movsd  0x1523(%rip),%xmm0
subsd  -0xa8e0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x14f28(%rbp)
ff
movslq -0x13c28(%rbp),%rax
movsd  0x1503(%rip),%xmm0
subsd  -0x128a0(%rbp,%rax,8),%xmm0
fe ff
cvttsd2si %xmm0,%edi
call   10b0 <log@plt>
movsd  -0x14f28(%rbp),%xmm1
ff
movsd  -0x14f20(%rbp),%xmm0
ff
movsd  -0x14f18(%rbp),%xmm2
ff
cvtsi2sd %eax,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
addsd  -0x13c20(%rbp),%xmm0
ff
movsd  %xmm0,-0x13c20(%rbp)
ff
mov    -0x13c28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c28(%rbp)
jmp    1a85 <main+0x8d5>
movsd  -0x13c20(%rbp),%xmm0
ff
movsd  0x149e(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x13c20(%rbp)
ff
mov    -0x13c14(%rbp),%eax
mov    $0x3e8,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1bc1 <main+0xa11>
mov    -0x13c14(%rbp),%esi
movsd  -0x13c20(%rbp),%xmm0
ff
lea    0x1501(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x13c10(%rbp),%rdi
mov    -0x13c14(%rbp),%edx
movsd  -0x13c20(%rbp),%xmm0
ff
lea    0x14de(%rip),%rsi
call   1090 <fprintf@plt>
movl   $0x0,-0x13c28(%rbp)
cmpl   $0x258,-0x13c28(%rbp)
jge    1c40 <main+0xa90>
movslq -0x13c28(%rbp),%rax
movsd  -0x128a0(%rbp,%rax,8),%xmm0
fe ff
movslq -0x13c28(%rbp),%rax
subsd  -0xa8e0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x13c28(%rbp),%rax
movsd  %xmm0,-0x13b60(%rbp,%rax,8)
fe ff
mov    -0x13c28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c28(%rbp)
jmp    1bec <main+0xa3c>
movl   $0x0,-0x13c24(%rbp)
cmpl   $0x8,-0x13c24(%rbp)
jge    1e16 <main+0xc66>
lea    -0x14ef0(%rbp),%rdi
xor    %esi,%esi
mov    $0x12c0,%edx
call   1070 <memset@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x14ef8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x14f00(%rbp)
ff
movl   $0x0,-0x13c28(%rbp)
cmpl   $0x258,-0x13c28(%rbp)
jge    1d0f <main+0xb5f>
movslq -0x13c28(%rbp),%rax
movsd  -0x13b60(%rbp,%rax,8),%xmm0
fe ff
movslq -0x13c28(%rbp),%rcx
lea    -0x9620(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x13c24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movslq -0x13c28(%rbp),%rax
movsd  %xmm0,-0x14ef0(%rbp,%rax,8)
fe ff
movslq -0x13c28(%rbp),%rax
movsd  -0x13b60(%rbp,%rax,8),%xmm0
fe ff
addsd  -0x14f00(%rbp),%xmm0
ff
movsd  %xmm0,-0x14f00(%rbp)
ff
mov    -0x13c28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c28(%rbp)
jmp    1c8a <main+0xada>
movl   $0x0,-0x13c28(%rbp)
cmpl   $0x258,-0x13c28(%rbp)
jge    1d5d <main+0xbad>
movslq -0x13c28(%rbp),%rax
movsd  -0x14ef0(%rbp,%rax,8),%xmm0
fe ff
addsd  -0x14ef8(%rbp),%xmm0
ff
movsd  %xmm0,-0x14ef8(%rbp)
ff
mov    -0x13c28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c28(%rbp)
jmp    1d19 <main+0xb69>
movsd  0x12c3(%rip),%xmm1
mulsd  -0x14ef8(%rbp),%xmm1
ff
movsd  0x12ab(%rip),%xmm0
divsd  %xmm0,%xmm1
movslq -0x13c24(%rbp),%rax
movsd  -0xbbe0(%rbp,%rax,8),%xmm0
ff ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xbbe0(%rbp,%rax,8)
ff ff
movl   $0x0,-0x13c28(%rbp)
cmpl   $0x258,-0x13c28(%rbp)
jge    1dfd <main+0xc4d>
movsd  0x1270(%rip),%xmm1
mulsd  -0x14f00(%rbp),%xmm1
ff
movsd  0x1258(%rip),%xmm0
divsd  %xmm0,%xmm1
movslq -0x13c28(%rbp),%rax
movsd  -0xcea0(%rbp,%rax,8),%xmm0
ff ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xcea0(%rbp,%rax,8)
ff ff
mov    -0x13c28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c28(%rbp)
jmp    1da0 <main+0xbf0>
jmp    1e02 <main+0xc52>
mov    -0x13c24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c24(%rbp)
jmp    1c4a <main+0xa9a>
jmp    1e1b <main+0xc6b>
mov    -0x13c14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c14(%rbp)
jmp    1939 <main+0x789>
lea    -0x115e0(%rbp),%rdi
lea    -0x128a0(%rbp),%rsi
lea    -0x13b60(%rbp),%rdx
call   10a0 <reset_parameters@plt>
movl   $0x0,-0x13bf8(%rbp)
cmpl   $0xa8,-0x13bf8(%rbp)
jge    1f42 <main+0xd92>
movl   $0x0,-0x13bf4(%rbp)
cmpl   $0x8,-0x13bf4(%rbp)
jge    1ee0 <main+0xd30>
movslq -0x13bf4(%rbp),%rax
movsd  -0xbbe0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x13bf8(%rbp),%rcx
lea    -0xf8a0(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x13bf4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x13bf8(%rbp),%rax
movsd  -0x115e0(%rbp,%rax,8),%xmm1
fe ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x115e0(%rbp,%rax,8)
fe ff
mov    -0x13bf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13bf4(%rbp)
jmp    1e6d <main+0xcbd>
movslq -0x13bf8(%rbp),%rax
movsd  -0xcea0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x13bf8(%rbp),%rax
addsd  -0x115e0(%rbp,%rax,8),%xmm0
fe ff
movsd  %xmm0,-0x115e0(%rbp,%rax,8)
fe ff
movslq -0x13bf8(%rbp),%rax
movsd  -0x115e0(%rbp,%rax,8),%xmm0
fe ff
call   1030 <sigmoid@plt>
movslq -0x13bf8(%rbp),%rax
movsd  %xmm0,-0x10320(%rbp,%rax,8)
fe ff
mov    -0x13bf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13bf8(%rbp)
jmp    1e53 <main+0xca3>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x14f08(%rbp)
ff
movl   $0x0,-0x13bf8(%rbp)
cmpl   $0xa8,-0x13bf8(%rbp)
jge    2062 <main+0xeb2>
movslq -0x13bf8(%rbp),%rax
movsd  -0x10320(%rbp,%rax,8),%xmm0
fe ff
movsd  0x1099(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1fa6 <main+0xdf6>
movslq -0x13bf8(%rbp),%rax
movsd  0x1068(%rip),%xmm0
movsd  %xmm0,-0x10320(%rbp,%rax,8)
fe ff
jmp    1fdc <main+0xe2c>
movslq -0x13bf8(%rbp),%rax
movsd  0x1063(%rip),%xmm0
ucomisd -0x10320(%rbp,%rax,8),%xmm0
fe ff
jbe    1fd7 <main+0xe27>
movslq -0x13bf8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x10320(%rbp,%rax,8)
fe ff
jmp    1fdc <main+0xe2c>
movslq -0x13bf8(%rbp),%rax
movsd  -0x10320(%rbp,%rax,8),%xmm0
fe ff
movslq -0x13bf8(%rbp),%rax
ucomisd -0xfde0(%rbp,%rax,8),%xmm0
ff ff
jne    2020 <main+0xe70>
jp     2020 <main+0xe70>
movsd  0xff0(%rip),%xmm0
addsd  -0x14f08(%rbp),%xmm0
ff
movsd  %xmm0,-0x14f08(%rbp)
ff
movslq -0x13bf8(%rbp),%rax
movsd  -0xfde0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x13bf8(%rbp),%rax
movsd  -0x10320(%rbp,%rax,8),%xmm1
fe ff
lea    0x109d(%rip),%rdi
mov    $0x2,%al
call   1060 <printf@plt>
mov    -0x13bf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13bf8(%rbp)
jmp    1f57 <main+0xda7>
movsd  -0x14f08(%rbp),%xmm0
ff
movsd  0xf9e(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  0xf8a(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x14f10(%rbp)
ff
movsd  -0x14f10(%rbp),%xmm0
ff
lea    0x106d(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
lea    -0xbbe0(%rbp),%rdi
lea    -0xcea0(%rbp),%rsi
lea    -0x13be0(%rbp),%rdx
call   1050 <export_weights@plt>
mov    -0x13c10(%rbp),%rdi
call   1040 <fclose@plt>
xor    %eax,%eax
add    $0x14f40,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x13678,%rsp
lea    0x2ab0(%rsp),%rdi
mov    $0x12c0,%edx
xor    %esi,%esi
call   1070 <memset@plt>
movabs $0x3ff0000000000000,%rax
mov    %rax,0x2ab0(%rsp)
lea    0x110f0(%rsp),%rdi
mov    $0x12c0,%edx
xor    %esi,%esi
call   1070 <memset@plt>
lea    0xe630(%rsp),%rdi
mov    $0x12c0,%edx
xor    %esi,%esi
call   1070 <memset@plt>
lea    0x1e3a(%rip),%rdi
lea    0x1e4d(%rip),%rsi
call   10c0 <fopen@plt>
test   %rax,%rax
je     12c1 <main+0x111>
mov    %rax,%r15
lea    0x123b0(%rsp),%rbp
xor    %ebx,%ebx
lea    0x1e2d(%rip),%r14
nop
lea    (%rsp,%rbx,1),%rdx
add    $0x3d70,%rdx
lea    0x3d78(%rsp,%rbx,1),%rcx
lea    0x3d80(%rsp,%rbx,1),%r8
lea    0x3d88(%rsp,%rbx,1),%r9
lea    0x3d90(%rsp,%rbx,1),%r10
lea    (%rsp,%rbx,1),%r11
add    $0x3d98,%r11
lea    (%rsp,%rbx,1),%r12
add    $0x3da0,%r12
lea    (%rsp,%rbx,1),%rax
add    $0x3da8,%rax
sub    $0x8,%rsp
mov    %r15,%rdi
mov    %r14,%rsi
push   %rbp
push   %rax
push   %r12
push   %r11
push   %r10
call   1080 <fscanf@plt>
add    $0x30,%rsp
add    $0x8,%rbp
add    $0x40,%rbx
cmp    $0x9600,%rbx
jne    1240 <main+0x90>
mov    %r15,%rdi
call   1040 <fclose@plt>
jmp    12cf <main+0x11f>
lea    0x1dc9(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x1dd4(%rip),%rdi
lea    0x1d8d(%rip),%rsi
call   10c0 <fopen@plt>
test   %rax,%rax
je     1381 <main+0x1d1>
mov    %rax,%r15
lea    0x10bb0(%rsp),%rbp
xor    %ebx,%ebx
lea    0x1d6d(%rip),%r14
nop
lea    (%rsp,%rbx,1),%rdx
add    $0xb0,%rdx
lea    0xb8(%rsp,%rbx,1),%rcx
lea    0xc0(%rsp,%rbx,1),%r8
lea    0xc8(%rsp,%rbx,1),%r9
lea    0xd0(%rsp,%rbx,1),%r10
lea    (%rsp,%rbx,1),%r11
add    $0xd8,%r11
lea    (%rsp,%rbx,1),%r12
add    $0xe0,%r12
lea    (%rsp,%rbx,1),%rax
add    $0xe8,%rax
sub    $0x8,%rsp
mov    %r15,%rdi
mov    %r14,%rsi
push   %rbp
push   %rax
push   %r12
push   %r11
push   %r10
call   1080 <fscanf@plt>
add    $0x30,%rsp
add    $0x8,%rbp
add    $0x40,%rbx
cmp    $0x2a00,%rbx
jne    1300 <main+0x150>
mov    %r15,%rdi
call   1040 <fclose@plt>
jmp    138f <main+0x1df>
lea    0x1d09(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
xorpd  %xmm7,%xmm7
mov    $0x140,%eax
nopl   0x0(%rax,%rax,1)
addsd  0x3c30(%rsp,%rax,1),%xmm7
addsd  0x3c70(%rsp,%rax,1),%xmm7
addsd  0x3cb0(%rsp,%rax,1),%xmm7
addsd  0x3cf0(%rsp,%rax,1),%xmm7
addsd  0x3d30(%rsp,%rax,1),%xmm7
addsd  0x3d70(%rsp,%rax,1),%xmm7
add    $0x180,%rax
cmp    $0x9740,%rax
jne    13a0 <main+0x1f0>
divsd  0x1c14(%rip),%xmm7
xorpd  %xmm6,%xmm6
mov    $0x148,%eax
cs nopw 0x0(%rax,%rax,1)
nop
addsd  0x3c30(%rsp,%rax,1),%xmm6
addsd  0x3c70(%rsp,%rax,1),%xmm6
addsd  0x3cb0(%rsp,%rax,1),%xmm6
addsd  0x3cf0(%rsp,%rax,1),%xmm6
addsd  0x3d30(%rsp,%rax,1),%xmm6
addsd  0x3d70(%rsp,%rax,1),%xmm6
add    $0x180,%rax
cmp    $0x9748,%rax
jne    1400 <main+0x250>
divsd  0x1bb4(%rip),%xmm6
xorpd  %xmm5,%xmm5
mov    $0x150,%eax
cs nopw 0x0(%rax,%rax,1)
nop
addsd  0x3c30(%rsp,%rax,1),%xmm5
addsd  0x3c70(%rsp,%rax,1),%xmm5
addsd  0x3cb0(%rsp,%rax,1),%xmm5
addsd  0x3cf0(%rsp,%rax,1),%xmm5
addsd  0x3d30(%rsp,%rax,1),%xmm5
addsd  0x3d70(%rsp,%rax,1),%xmm5
add    $0x180,%rax
cmp    $0x9750,%rax
jne    1460 <main+0x2b0>
divsd  0x1b54(%rip),%xmm5
xorpd  %xmm4,%xmm4
mov    $0x158,%eax
cs nopw 0x0(%rax,%rax,1)
nop
addsd  0x3c30(%rsp,%rax,1),%xmm4
addsd  0x3c70(%rsp,%rax,1),%xmm4
addsd  0x3cb0(%rsp,%rax,1),%xmm4
addsd  0x3cf0(%rsp,%rax,1),%xmm4
addsd  0x3d30(%rsp,%rax,1),%xmm4
addsd  0x3d70(%rsp,%rax,1),%xmm4
add    $0x180,%rax
cmp    $0x9758,%rax
jne    14c0 <main+0x310>
divsd  0x1af4(%rip),%xmm4
xorpd  %xmm3,%xmm3
mov    $0x160,%eax
cs nopw 0x0(%rax,%rax,1)
nop
addsd  0x3c30(%rsp,%rax,1),%xmm3
addsd  0x3c70(%rsp,%rax,1),%xmm3
addsd  0x3cb0(%rsp,%rax,1),%xmm3
addsd  0x3cf0(%rsp,%rax,1),%xmm3
addsd  0x3d30(%rsp,%rax,1),%xmm3
addsd  0x3d70(%rsp,%rax,1),%xmm3
add    $0x180,%rax
cmp    $0x9760,%rax
jne    1520 <main+0x370>
divsd  0x1a94(%rip),%xmm3
xorpd  %xmm2,%xmm2
mov    $0x168,%eax
cs nopw 0x0(%rax,%rax,1)
nop
addsd  0x3c30(%rsp,%rax,1),%xmm2
addsd  0x3c70(%rsp,%rax,1),%xmm2
addsd  0x3cb0(%rsp,%rax,1),%xmm2
addsd  0x3cf0(%rsp,%rax,1),%xmm2
addsd  0x3d30(%rsp,%rax,1),%xmm2
addsd  0x3d70(%rsp,%rax,1),%xmm2
add    $0x180,%rax
cmp    $0x9768,%rax
jne    1580 <main+0x3d0>
divsd  0x1a34(%rip),%xmm2
xorpd  %xmm1,%xmm1
mov    $0x170,%eax
cs nopw 0x0(%rax,%rax,1)
nop
addsd  0x3c30(%rsp,%rax,1),%xmm1
addsd  0x3c70(%rsp,%rax,1),%xmm1
addsd  0x3cb0(%rsp,%rax,1),%xmm1
addsd  0x3cf0(%rsp,%rax,1),%xmm1
addsd  0x3d30(%rsp,%rax,1),%xmm1
addsd  0x3d70(%rsp,%rax,1),%xmm1
add    $0x180,%rax
cmp    $0x9770,%rax
jne    15e0 <main+0x430>
divsd  0x19d4(%rip),%xmm1
xorpd  %xmm10,%xmm10
mov    $0x178,%eax
cs nopw 0x0(%rax,%rax,1)
addsd  0x3c30(%rsp,%rax,1),%xmm10
addsd  0x3c70(%rsp,%rax,1),%xmm10
addsd  0x3cb0(%rsp,%rax,1),%xmm10
addsd  0x3cf0(%rsp,%rax,1),%xmm10
addsd  0x3d30(%rsp,%rax,1),%xmm10
addsd  0x3d70(%rsp,%rax,1),%xmm10
add    $0x180,%rax
cmp    $0x9778,%rax
jne    1640 <main+0x490>
divsd  0x196d(%rip),%xmm10
movapd %xmm7,%xmm9
unpcklpd %xmm7,%xmm9
mov    $0x40,%eax
movapd 0x1985(%rip),%xmm8
nopl   0x0(%rax,%rax,1)
movsd  0x3d30(%rsp,%rax,1),%xmm0
movhpd 0x3d70(%rsp,%rax,1),%xmm0
subpd  %xmm9,%xmm0
divpd  %xmm8,%xmm0
movlpd %xmm0,0x3d30(%rsp,%rax,1)
movhpd %xmm0,0x3d70(%rsp,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x95c0,%rax
jne    16b0 <main+0x500>
movsd  0xd2f0(%rsp),%xmm0
movsd  0xd330(%rsp),%xmm9
subsd  %xmm7,%xmm0
movsd  0x18f6(%rip),%xmm11
divsd  %xmm11,%xmm0
movsd  %xmm0,0xd2f0(%rsp)
subsd  %xmm7,%xmm9
divsd  %xmm11,%xmm9
movsd  %xmm9,0xd330(%rsp)
movapd %xmm6,%xmm7
unpcklpd %xmm6,%xmm7
mov    $0x48,%eax
nopl   0x0(%rax)
movsd  0x3d30(%rsp,%rax,1),%xmm0
movhpd 0x3d70(%rsp,%rax,1),%xmm0
subpd  %xmm7,%xmm0
divpd  %xmm8,%xmm0
movlpd %xmm0,0x3d30(%rsp,%rax,1)
movhpd %xmm0,0x3d70(%rsp,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x95c8,%rax
jne    1740 <main+0x590>
movsd  0xd2f8(%rsp),%xmm0
movsd  0xd338(%rsp),%xmm9
subsd  %xmm6,%xmm0
movsd  0x1868(%rip),%xmm7
divsd  %xmm7,%xmm0
movsd  %xmm0,0xd2f8(%rsp)
subsd  %xmm6,%xmm9
divsd  %xmm7,%xmm9
movsd  %xmm9,0xd338(%rsp)
movapd %xmm5,%xmm6
unpcklpd %xmm5,%xmm6
mov    $0x50,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  0x3d30(%rsp,%rax,1),%xmm0
movhpd 0x3d70(%rsp,%rax,1),%xmm0
subpd  %xmm6,%xmm0
divpd  %xmm8,%xmm0
movlpd %xmm0,0x3d30(%rsp,%rax,1)
movhpd %xmm0,0x3d70(%rsp,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x95d0,%rax
jne    17d0 <main+0x620>
movsd  0xd300(%rsp),%xmm0
movsd  0xd340(%rsp),%xmm6
subsd  %xmm5,%xmm0
movsd  0x17d9(%rip),%xmm7
divsd  %xmm7,%xmm0
movsd  %xmm0,0xd300(%rsp)
subsd  %xmm5,%xmm6
divsd  %xmm7,%xmm6
movsd  %xmm6,0xd340(%rsp)
movapd %xmm4,%xmm5
unpcklpd %xmm4,%xmm5
mov    $0x58,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x3d30(%rsp,%rax,1),%xmm0
movhpd 0x3d70(%rsp,%rax,1),%xmm0
subpd  %xmm5,%xmm0
divpd  %xmm8,%xmm0
movlpd %xmm0,0x3d30(%rsp,%rax,1)
movhpd %xmm0,0x3d70(%rsp,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x95d8,%rax
jne    1860 <main+0x6b0>
movsd  0xd308(%rsp),%xmm0
movsd  0xd348(%rsp),%xmm5
subsd  %xmm4,%xmm0
movsd  0x1749(%rip),%xmm6
divsd  %xmm6,%xmm0
movsd  %xmm0,0xd308(%rsp)
subsd  %xmm4,%xmm5
divsd  %xmm6,%xmm5
movsd  %xmm5,0xd348(%rsp)
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
mov    $0x60,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x3d30(%rsp,%rax,1),%xmm0
movhpd 0x3d70(%rsp,%rax,1),%xmm0
subpd  %xmm4,%xmm0
divpd  %xmm8,%xmm0
movlpd %xmm0,0x3d30(%rsp,%rax,1)
movhpd %xmm0,0x3d70(%rsp,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x95e0,%rax
jne    18f0 <main+0x740>
movsd  0xd310(%rsp),%xmm0
movsd  0xd350(%rsp),%xmm4
subsd  %xmm3,%xmm0
movsd  0x16b9(%rip),%xmm5
divsd  %xmm5,%xmm0
movsd  %xmm0,0xd310(%rsp)
subsd  %xmm3,%xmm4
divsd  %xmm5,%xmm4
movsd  %xmm4,0xd350(%rsp)
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
mov    $0x68,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x3d30(%rsp,%rax,1),%xmm0
movhpd 0x3d70(%rsp,%rax,1),%xmm0
subpd  %xmm3,%xmm0
divpd  %xmm8,%xmm0
movlpd %xmm0,0x3d30(%rsp,%rax,1)
movhpd %xmm0,0x3d70(%rsp,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x95e8,%rax
jne    1980 <main+0x7d0>
movsd  0xd318(%rsp),%xmm0
movsd  0xd358(%rsp),%xmm3
subsd  %xmm2,%xmm0
movsd  0x1629(%rip),%xmm4
divsd  %xmm4,%xmm0
movsd  %xmm0,0xd318(%rsp)
subsd  %xmm2,%xmm3
divsd  %xmm4,%xmm3
movsd  %xmm3,0xd358(%rsp)
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
mov    $0x70,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x3d30(%rsp,%rax,1),%xmm0
movhpd 0x3d70(%rsp,%rax,1),%xmm0
subpd  %xmm2,%xmm0
divpd  %xmm8,%xmm0
movlpd %xmm0,0x3d30(%rsp,%rax,1)
movhpd %xmm0,0x3d70(%rsp,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x95f0,%rax
jne    1a10 <main+0x860>
movsd  0xd320(%rsp),%xmm0
movsd  0xd360(%rsp),%xmm2
subsd  %xmm1,%xmm0
movsd  0x1599(%rip),%xmm3
divsd  %xmm3,%xmm0
movsd  %xmm0,0xd320(%rsp)
subsd  %xmm1,%xmm2
divsd  %xmm3,%xmm2
movsd  %xmm2,0xd360(%rsp)
movapd %xmm10,%xmm1
unpcklpd %xmm10,%xmm1
mov    $0x78,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x3d30(%rsp,%rax,1),%xmm0
movhpd 0x3d70(%rsp,%rax,1),%xmm0
subpd  %xmm1,%xmm0
divpd  %xmm8,%xmm0
movlpd %xmm0,0x3d30(%rsp,%rax,1)
movhpd %xmm0,0x3d70(%rsp,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x95f8,%rax
jne    1aa0 <main+0x8f0>
movsd  0xd328(%rsp),%xmm0
movsd  0xd368(%rsp),%xmm1
subsd  %xmm10,%xmm0
movsd  0x1508(%rip),%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,0xd328(%rsp)
subsd  %xmm10,%xmm1
divsd  %xmm2,%xmm1
movsd  %xmm1,0xd368(%rsp)
xorpd  %xmm7,%xmm7
mov    $0x140,%eax
addsd  -0x90(%rsp,%rax,1),%xmm7
ff ff
addsd  -0x50(%rsp,%rax,1),%xmm7
addsd  -0x10(%rsp,%rax,1),%xmm7
addsd  0x30(%rsp,%rax,1),%xmm7
addsd  0x70(%rsp,%rax,1),%xmm7
addsd  0xb0(%rsp,%rax,1),%xmm7
add    $0x180,%rax
cmp    $0x2b40,%rax
jne    1b20 <main+0x970>
divsd  0x14a8(%rip),%xmm7
movsd  %xmm7,0x70(%rsp)
xorpd  %xmm6,%xmm6
mov    $0x148,%eax
nop
addsd  -0x90(%rsp,%rax,1),%xmm6
ff ff
addsd  -0x50(%rsp,%rax,1),%xmm6
addsd  -0x10(%rsp,%rax,1),%xmm6
addsd  0x30(%rsp,%rax,1),%xmm6
addsd  0x70(%rsp,%rax,1),%xmm6
addsd  0xb0(%rsp,%rax,1),%xmm6
add    $0x180,%rax
cmp    $0x2b48,%rax
jne    1b70 <main+0x9c0>
divsd  0x1458(%rip),%xmm6
movsd  %xmm6,0x78(%rsp)
xorpd  %xmm5,%xmm5
mov    $0x150,%eax
nop
addsd  -0x90(%rsp,%rax,1),%xmm5
ff ff
addsd  -0x50(%rsp,%rax,1),%xmm5
addsd  -0x10(%rsp,%rax,1),%xmm5
addsd  0x30(%rsp,%rax,1),%xmm5
addsd  0x70(%rsp,%rax,1),%xmm5
addsd  0xb0(%rsp,%rax,1),%xmm5
add    $0x180,%rax
cmp    $0x2b50,%rax
jne    1bc0 <main+0xa10>
divsd  0x1408(%rip),%xmm5
movsd  %xmm5,0x80(%rsp)
xorpd  %xmm4,%xmm4
mov    $0x158,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addsd  -0x90(%rsp,%rax,1),%xmm4
ff ff
addsd  -0x50(%rsp,%rax,1),%xmm4
addsd  -0x10(%rsp,%rax,1),%xmm4
addsd  0x30(%rsp,%rax,1),%xmm4
addsd  0x70(%rsp,%rax,1),%xmm4
addsd  0xb0(%rsp,%rax,1),%xmm4
add    $0x180,%rax
cmp    $0x2b58,%rax
jne    1c20 <main+0xa70>
divsd  0x13a8(%rip),%xmm4
movsd  %xmm4,0x88(%rsp)
xorpd  %xmm3,%xmm3
mov    $0x160,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addsd  -0x90(%rsp,%rax,1),%xmm3
ff ff
addsd  -0x50(%rsp,%rax,1),%xmm3
addsd  -0x10(%rsp,%rax,1),%xmm3
addsd  0x30(%rsp,%rax,1),%xmm3
addsd  0x70(%rsp,%rax,1),%xmm3
addsd  0xb0(%rsp,%rax,1),%xmm3
add    $0x180,%rax
cmp    $0x2b60,%rax
jne    1c80 <main+0xad0>
divsd  0x1348(%rip),%xmm3
movsd  %xmm3,0x90(%rsp)
xorpd  %xmm2,%xmm2
mov    $0x168,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addsd  -0x90(%rsp,%rax,1),%xmm2
ff ff
addsd  -0x50(%rsp,%rax,1),%xmm2
addsd  -0x10(%rsp,%rax,1),%xmm2
addsd  0x30(%rsp,%rax,1),%xmm2
addsd  0x70(%rsp,%rax,1),%xmm2
addsd  0xb0(%rsp,%rax,1),%xmm2
add    $0x180,%rax
cmp    $0x2b68,%rax
jne    1ce0 <main+0xb30>
divsd  0x12e8(%rip),%xmm2
movsd  %xmm2,0x98(%rsp)
xorpd  %xmm1,%xmm1
mov    $0x170,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addsd  -0x90(%rsp,%rax,1),%xmm1
ff ff
addsd  -0x50(%rsp,%rax,1),%xmm1
addsd  -0x10(%rsp,%rax,1),%xmm1
addsd  0x30(%rsp,%rax,1),%xmm1
addsd  0x70(%rsp,%rax,1),%xmm1
addsd  0xb0(%rsp,%rax,1),%xmm1
add    $0x180,%rax
cmp    $0x2b70,%rax
jne    1d40 <main+0xb90>
divsd  0x1288(%rip),%xmm1
movsd  %xmm1,0xa0(%rsp)
xorpd  %xmm10,%xmm10
mov    $0x178,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addsd  -0x90(%rsp,%rax,1),%xmm10
ff ff ff
addsd  -0x50(%rsp,%rax,1),%xmm10
addsd  -0x10(%rsp,%rax,1),%xmm10
addsd  0x30(%rsp,%rax,1),%xmm10
addsd  0x70(%rsp,%rax,1),%xmm10
addsd  0xb0(%rsp,%rax,1),%xmm10
add    $0x180,%rax
cmp    $0x2b78,%rax
jne    1da0 <main+0xbf0>
divsd  0x1221(%rip),%xmm10
movsd  %xmm10,0xa8(%rsp)
movapd %xmm7,%xmm9
unpcklpd %xmm7,%xmm9
mov    $0x40,%eax
movapd 0x1237(%rip),%xmm8
nopl   0x0(%rax)
movsd  0x70(%rsp,%rax,1),%xmm0
movhpd 0xb0(%rsp,%rax,1),%xmm0
subpd  %xmm9,%xmm0
divpd  %xmm8,%xmm0
movlpd %xmm0,0x70(%rsp,%rax,1)
movhpd %xmm0,0xb0(%rsp,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x29c0,%rax
jne    1e10 <main+0xc60>
movsd  0x2a30(%rsp),%xmm0
movsd  0x2a70(%rsp),%xmm11
subsd  %xmm7,%xmm0
movsd  0x11a4(%rip),%xmm9
divsd  %xmm9,%xmm0
movsd  %xmm0,0x2a30(%rsp)
subsd  %xmm7,%xmm11
divsd  %xmm9,%xmm11
movsd  %xmm11,0x2a70(%rsp)
movapd %xmm6,%xmm7
unpcklpd %xmm6,%xmm7
mov    $0x48,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x70(%rsp,%rax,1),%xmm0
movhpd 0xb0(%rsp,%rax,1),%xmm0
subpd  %xmm7,%xmm0
divpd  %xmm8,%xmm0
movlpd %xmm0,0x70(%rsp,%rax,1)
movhpd %xmm0,0xb0(%rsp,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x29c8,%rax
jne    1ea0 <main+0xcf0>
movsd  0x2a38(%rsp),%xmm0
movsd  0x2a78(%rsp),%xmm7
subsd  %xmm6,%xmm0
divsd  %xmm9,%xmm0
movsd  %xmm0,0x2a38(%rsp)
subsd  %xmm6,%xmm7
divsd  %xmm9,%xmm7
movsd  %xmm7,0x2a78(%rsp)
movapd %xmm5,%xmm6
unpcklpd %xmm5,%xmm6
mov    $0x50,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  0x70(%rsp,%rax,1),%xmm0
movhpd 0xb0(%rsp,%rax,1),%xmm0
subpd  %xmm6,%xmm0
divpd  %xmm8,%xmm0
movlpd %xmm0,0x70(%rsp,%rax,1)
movhpd %xmm0,0xb0(%rsp,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x29d0,%rax
jne    1f20 <main+0xd70>
movsd  0x2a40(%rsp),%xmm0
movsd  0x2a80(%rsp),%xmm6
subsd  %xmm5,%xmm0
divsd  %xmm9,%xmm0
movsd  %xmm0,0x2a40(%rsp)
subsd  %xmm5,%xmm6
divsd  %xmm9,%xmm6
movsd  %xmm6,0x2a80(%rsp)
movapd %xmm4,%xmm5
unpcklpd %xmm4,%xmm5
mov    $0x58,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  0x70(%rsp,%rax,1),%xmm0
movhpd 0xb0(%rsp,%rax,1),%xmm0
subpd  %xmm5,%xmm0
divpd  %xmm8,%xmm0
movlpd %xmm0,0x70(%rsp,%rax,1)
movhpd %xmm0,0xb0(%rsp,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x29d8,%rax
jne    1fa0 <main+0xdf0>
movsd  0x2a48(%rsp),%xmm0
movsd  0x2a88(%rsp),%xmm5
subsd  %xmm4,%xmm0
divsd  %xmm9,%xmm0
movsd  %xmm0,0x2a48(%rsp)
subsd  %xmm4,%xmm5
divsd  %xmm9,%xmm5
movsd  %xmm5,0x2a88(%rsp)
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
mov    $0x60,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  0x70(%rsp,%rax,1),%xmm0
movhpd 0xb0(%rsp,%rax,1),%xmm0
subpd  %xmm4,%xmm0
divpd  %xmm8,%xmm0
movlpd %xmm0,0x70(%rsp,%rax,1)
movhpd %xmm0,0xb0(%rsp,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x29e0,%rax
jne    2020 <main+0xe70>
movsd  0x2a50(%rsp),%xmm0
movsd  0x2a90(%rsp),%xmm4
subsd  %xmm3,%xmm0
divsd  %xmm9,%xmm0
movsd  %xmm0,0x2a50(%rsp)
subsd  %xmm3,%xmm4
divsd  %xmm9,%xmm4
movsd  %xmm4,0x2a90(%rsp)
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
mov    $0x68,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  0x70(%rsp,%rax,1),%xmm0
movhpd 0xb0(%rsp,%rax,1),%xmm0
subpd  %xmm3,%xmm0
divpd  %xmm8,%xmm0
movlpd %xmm0,0x70(%rsp,%rax,1)
movhpd %xmm0,0xb0(%rsp,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x29e8,%rax
jne    20a0 <main+0xef0>
movsd  0x2a58(%rsp),%xmm0
movsd  0x2a98(%rsp),%xmm3
subsd  %xmm2,%xmm0
divsd  %xmm9,%xmm0
movsd  %xmm0,0x2a58(%rsp)
subsd  %xmm2,%xmm3
divsd  %xmm9,%xmm3
movsd  %xmm3,0x2a98(%rsp)
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
mov    $0x70,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  0x70(%rsp,%rax,1),%xmm0
movhpd 0xb0(%rsp,%rax,1),%xmm0
subpd  %xmm2,%xmm0
divpd  %xmm8,%xmm0
movlpd %xmm0,0x70(%rsp,%rax,1)
movhpd %xmm0,0xb0(%rsp,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x29f0,%rax
jne    2120 <main+0xf70>
movsd  0x2a60(%rsp),%xmm0
movsd  0x2aa0(%rsp),%xmm2
subsd  %xmm1,%xmm0
divsd  %xmm9,%xmm0
movsd  %xmm0,0x2a60(%rsp)
subsd  %xmm1,%xmm2
divsd  %xmm9,%xmm2
movsd  %xmm2,0x2aa0(%rsp)
movapd %xmm10,%xmm1
unpcklpd %xmm10,%xmm1
mov    $0x78,%eax
nopl   0x0(%rax,%rax,1)
movsd  0x70(%rsp,%rax,1),%xmm0
movhpd 0xb0(%rsp,%rax,1),%xmm0
subpd  %xmm1,%xmm0
divpd  %xmm8,%xmm0
movlpd %xmm0,0x70(%rsp,%rax,1)
movhpd %xmm0,0xb0(%rsp,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x29f8,%rax
jne    21a0 <main+0xff0>
movsd  0x2a68(%rsp),%xmm0
movsd  0x2aa8(%rsp),%xmm1
subsd  %xmm10,%xmm0
divsd  %xmm9,%xmm0
movsd  %xmm0,0x2a68(%rsp)
subsd  %xmm10,%xmm1
divsd  %xmm9,%xmm1
movsd  %xmm1,0x2aa8(%rsp)
lea    0x20(%rsp),%rdi
call   10d0 <Weights_init@plt>
lea    0xead(%rip),%rdi
lea    0xeb6(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,%r14
xor    %ebx,%ebx
lea    0xd370(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x110f0(%rsp),%rdi
lea    0xe630(%rsp),%rsi
lea    0xf8f0(%rsp),%rdx
call   10a0 <reset_parameters@plt>
xor    %ebp,%ebp
nop
movsd  0x20(%rsp),%xmm0
movsd  0x28(%rsp),%xmm1
mulsd  0x3d70(%rsp,%rbp,8),%xmm0
addsd  0x110f0(%rsp,%rbp,1),%xmm0
mulsd  0x3d78(%rsp,%rbp,8),%xmm1
addsd  %xmm0,%xmm1
movsd  0x30(%rsp),%xmm0
mulsd  0x3d80(%rsp,%rbp,8),%xmm0
addsd  %xmm1,%xmm0
movsd  0x38(%rsp),%xmm1
mulsd  0x3d88(%rsp,%rbp,8),%xmm1
addsd  %xmm0,%xmm1
movsd  0x40(%rsp),%xmm0
mulsd  0x3d90(%rsp,%rbp,8),%xmm0
addsd  %xmm1,%xmm0
movsd  0x48(%rsp),%xmm1
mulsd  0x3d98(%rsp,%rbp,8),%xmm1
addsd  %xmm0,%xmm1
movsd  0x50(%rsp),%xmm2
mulsd  0x3da0(%rsp,%rbp,8),%xmm2
addsd  %xmm1,%xmm2
movsd  0x58(%rsp),%xmm0
mulsd  0x3da8(%rsp,%rbp,8),%xmm0
addsd  %xmm2,%xmm0
addsd  0x2ab0(%rsp,%rbp,1),%xmm0
movsd  %xmm0,0x110f0(%rsp,%rbp,1)
call   1030 <sigmoid@plt>
movsd  %xmm0,0xe630(%rsp,%rbp,1)
add    $0x8,%rbp
cmp    $0x12c0,%rbp
jne    2260 <main+0x10b0>
xorpd  %xmm1,%xmm1
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  %xmm1,0x10(%rsp)
movsd  0x123b0(%rsp,%rbp,8),%xmm0
movsd  %xmm0,0x8(%rsp)
cvttsd2si 0xe630(%rsp,%rbp,8),%edi
call   10b0 <log@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0xc92(%rip),%xmm0
movapd %xmm0,%xmm1
subsd  0x123b0(%rsp,%rbp,8),%xmm1
movsd  %xmm1,0x68(%rsp)
subsd  0xe630(%rsp,%rbp,8),%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <log@plt>
movsd  0x10(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x68(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
subsd  %xmm0,%xmm1
add    $0x1,%rbp
cmp    $0x258,%rbp
jne    2340 <main+0x1190>
divsd  0xc27(%rip),%xmm1
imul   $0x26e978d5,%ebx,%eax
ror    $0x3,%eax
cmp    $0x418937,%eax
ja     2409 <main+0x1259>
lea    0xceb(%rip),%rdi
mov    %ebx,%esi
movapd %xmm1,%xmm0
mov    $0x1,%al
movsd  %xmm1,0x10(%rsp)
call   1060 <printf@plt>
movsd  0x10(%rsp),%xmm1
mov    %r14,%rdi
lea    0xcc8(%rip),%rsi
mov    %ebx,%edx
movapd %xmm1,%xmm0
call   1090 <fprintf@plt>
mov    $0x6,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd 0xe600(%rsp,%rax,8),%xmm0
movapd 0xe610(%rsp,%rax,8),%xmm1
movapd 0xe620(%rsp,%rax,8),%xmm2
movapd 0xe630(%rsp,%rax,8),%xmm3
subpd  0x12380(%rsp,%rax,8),%xmm0
subpd  0x12390(%rsp,%rax,8),%xmm1
movapd %xmm0,0xf8c0(%rsp,%rax,8)
movapd %xmm1,0xf8d0(%rsp,%rax,8)
subpd  0x123a0(%rsp,%rax,8),%xmm2
subpd  0x123b0(%rsp,%rax,8),%xmm3
movapd %xmm2,0xf8e0(%rsp,%rax,8)
movapd %xmm3,0xf8f0(%rsp,%rax,8)
add    $0x8,%rax
cmp    $0x25e,%rax
jne    2430 <main+0x1280>
lea    0x3d70(%rsp),%r12
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0x12c0,%edx
mov    %r15,%rdi
xor    %esi,%esi
call   1070 <memset@plt>
xorpd  %xmm0,%xmm0
mov    $0x10,%eax
nopl   0x0(%rax,%rax,1)
movsd  0xf8e0(%rsp,%rax,1),%xmm1
movsd  0xf8e8(%rsp,%rax,1),%xmm2
addsd  %xmm1,%xmm0
mulsd  -0x80(%r12,%rax,8),%xmm1
movsd  %xmm1,0xd360(%rsp,%rax,1)
addsd  %xmm2,%xmm0
mulsd  -0x40(%r12,%rax,8),%xmm2
movsd  %xmm2,0xd368(%rsp,%rax,1)
movsd  0xf8f0(%rsp,%rax,1),%xmm1
movsd  (%r12,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0xd370(%rsp,%rax,1)
addsd  %xmm1,%xmm0
add    $0x18,%rax
cmp    $0x12d0,%rax
jne    24e0 <main+0x1330>
xorpd  %xmm1,%xmm1
mov    $0x7,%eax
nop
addsd  0xd338(%rsp,%rax,8),%xmm1
addsd  0xd340(%rsp,%rax,8),%xmm1
addsd  0xd348(%rsp,%rax,8),%xmm1
addsd  0xd350(%rsp,%rax,8),%xmm1
addsd  0xd358(%rsp,%rax,8),%xmm1
addsd  0xd360(%rsp,%rax,8),%xmm1
addsd  0xd368(%rsp,%rax,8),%xmm1
addsd  0xd370(%rsp,%rax,8),%xmm1
add    $0x8,%rax
cmp    $0x25f,%rax
jne    2550 <main+0x13a0>
movsd  0xa6c(%rip),%xmm4
mulsd  %xmm4,%xmm1
movsd  0xa48(%rip),%xmm3
divsd  %xmm3,%xmm1
movsd  0x20(%rsp,%r13,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,0x20(%rsp,%r13,8)
mulsd  %xmm4,%xmm0
divsd  %xmm3,%xmm0
unpcklpd %xmm0,%xmm0
mov    $0xa,%eax
nop
movapd 0x2a60(%rsp,%rax,8),%xmm1
movapd 0x2a70(%rsp,%rax,8),%xmm2
movapd 0x2a80(%rsp,%rax,8),%xmm3
movapd 0x2a90(%rsp,%rax,8),%xmm4
subpd  %xmm0,%xmm1
subpd  %xmm0,%xmm2
movapd %xmm1,0x2a60(%rsp,%rax,8)
movapd %xmm2,0x2a70(%rsp,%rax,8)
subpd  %xmm0,%xmm3
subpd  %xmm0,%xmm4
movapd %xmm3,0x2a80(%rsp,%rax,8)
movapd %xmm4,0x2a90(%rsp,%rax,8)
movapd 0x2aa0(%rsp,%rax,8),%xmm1
movapd 0x2ab0(%rsp,%rax,8),%xmm2
subpd  %xmm0,%xmm1
subpd  %xmm0,%xmm2
movapd %xmm1,0x2aa0(%rsp,%rax,8)
movapd %xmm2,0x2ab0(%rsp,%rax,8)
add    $0xc,%rax
cmp    $0x262,%rax
jne    25e0 <main+0x1430>
add    $0x1,%r13
add    $0x8,%r12
cmp    $0x8,%r13
jne    24c0 <main+0x1310>
add    $0x1,%ebx
cmp    $0xfa0,%ebx
jne    2240 <main+0x1090>
lea    0x110f0(%rsp),%rdi
lea    0xe630(%rsp),%rsi
lea    0xf8f0(%rsp),%rdx
call   10a0 <reset_parameters@plt>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x20(%rsp),%xmm0
movsd  0x28(%rsp),%xmm1
mulsd  0xb0(%rsp,%rbx,8),%xmm0
addsd  0x110f0(%rsp,%rbx,1),%xmm0
mulsd  0xb8(%rsp,%rbx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  0x30(%rsp),%xmm0
mulsd  0xc0(%rsp,%rbx,8),%xmm0
addsd  %xmm1,%xmm0
movsd  0x38(%rsp),%xmm1
mulsd  0xc8(%rsp,%rbx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  0x40(%rsp),%xmm0
mulsd  0xd0(%rsp,%rbx,8),%xmm0
addsd  %xmm1,%xmm0
movsd  0x48(%rsp),%xmm1
mulsd  0xd8(%rsp,%rbx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  0x50(%rsp),%xmm2
mulsd  0xe0(%rsp,%rbx,8),%xmm2
addsd  %xmm1,%xmm2
movsd  0x58(%rsp),%xmm0
mulsd  0xe8(%rsp,%rbx,8),%xmm0
addsd  %xmm2,%xmm0
addsd  0x2ab0(%rsp,%rbx,1),%xmm0
movsd  %xmm0,0x110f0(%rsp,%rbx,1)
call   1030 <sigmoid@plt>
movsd  %xmm0,0xd370(%rsp,%rbx,1)
add    $0x8,%rbx
cmp    $0x540,%rbx
jne    26c0 <main+0x1510>
xorpd  %xmm2,%xmm2
xor    %ebp,%ebp
lea    0x969(%rip),%rbx
movsd  0x86d(%rip),%xmm4
jmp    2812 <main+0x1662>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  %xmm0,0xd370(%rsp,%rbp,8)
movapd %xmm0,%xmm1
movsd  0x10bb0(%rsp,%rbp,8),%xmm0
movapd %xmm2,%xmm3
addsd  %xmm4,%xmm3
movapd %xmm1,%xmm5
cmpeqsd %xmm0,%xmm5
andpd  %xmm5,%xmm3
andnpd %xmm2,%xmm5
orpd   %xmm3,%xmm5
movapd %xmm5,0x10(%rsp)
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x815(%rip),%xmm4
movapd 0x10(%rsp),%xmm0
add    $0x1,%rbp
movapd %xmm0,%xmm2
cmp    $0xa8,%rbp
je     2844 <main+0x1694>
movsd  0xd370(%rsp,%rbp,8),%xmm1
ucomisd 0x7fd(%rip),%xmm1
movapd %xmm4,%xmm0
ja     27b0 <main+0x1600>
xorpd  %xmm0,%xmm0
movsd  0x7eb(%rip),%xmm3
ucomisd %xmm1,%xmm3
ja     27b0 <main+0x1600>
jmp    27bd <main+0x160d>
divsd  0x7bc(%rip),%xmm0
mulsd  0x7d4(%rip),%xmm0
lea    0x8cb(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
lea    0x20(%rsp),%rdi
lea    0x2ab0(%rsp),%rsi
lea    0x70(%rsp),%rdx
call   1050 <export_weights@plt>
mov    %r14,%rdi
call   1040 <fclose@plt>
xor    %eax,%eax
add    $0x13678,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [26 x i8] c"pima-indians-diabetes.txt\00"
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [37 x i8] c"%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf\0A\00"
@.str.3 = [25 x i8] c"File Can not be opened !\00"
@.str.4 = [31 x i8] c"pima-indians-diabetes_test.txt\00"
@.str.5 = [16 x i8] c"Cost_report.txt\00"
@.str.6 = [2 x i8] c"a\00"
@.str.7 = [41 x i8] c"iteration:%d --------------> cost: %lf \0A\00"
@.str.8 = [34 x i8] c"actual: [%lf] ,predicted: [%lf].\0A\00"
@.str.9 = [28 x i8] c"\0A\0A\0A Test Accuracy is: %lf \00"
define i32 @main() {
%1 = alloca [600 x [8 x double]]
%2 = alloca [600 x double]
%3 = alloca [8 x double]
%4 = alloca [600 x double]
%5 = alloca [168 x [8 x double]]
%6 = alloca [168 x double]
%7 = alloca [168 x double]
%8 = alloca [600 x double]
%9 = alloca [600 x double]
%10 = alloca [600 x double]
%11 = alloca [8 x double]
%12 = alloca [600 x double]
%13 = bitcast [600 x [8 x double]]* %1 to i8*
%14 = bitcast [600 x double]* %2 to i8*
%15 = bitcast [8 x double]* %3 to i8*
%16 = bitcast [600 x double]* %4 to i8*
%17 = getelementptr inbounds [600 x double], [600 x double]* %4, i64 0, i64 0
store double 1.000000e+00, double* %17
%18 = bitcast [168 x [8 x double]]* %5 to i8*
%19 = bitcast [168 x double]* %6 to i8*
%20 = bitcast [168 x double]* %7 to i8*
%21 = bitcast [600 x double]* %8 to i8*
%22 = bitcast [600 x double]* %9 to i8*
%23 = bitcast [600 x double]* %10 to i8*
%24 = bitcast [8 x double]* %11 to i8*
%25 = tail call i32* @fopen(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%26 = icmp eq i32* %25, null
br i1 %26, label %43, label %27
27: ; preds = %0, %27
%28 = phi i64 [ %39, %27 ], [ 0, %0 ]
%29 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %28, i64 0
%30 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %28, i64 1
%31 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %28, i64 2
%32 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %28, i64 3
%33 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %28, i64 4
%34 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %28, i64 5
%35 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %28, i64 6
%36 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %28, i64 7
%37 = getelementptr inbounds [600 x double], [600 x double]* %2, i64 0, i64 %28
%38 = call i32 @fscanf(i32* %25, i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.2, i64 0, i64 0), double* %29, double* %30, double* %31, double* %32, double* %33, double* %34, double* %35, double* %36, double* %37)
%39 = add nuw nsw i64 %28, 1
%40 = icmp eq i64 %39, 600
br i1 %40, label %41, label %27
41: ; preds = %27
%42 = call i32 @fclose(i32* %25)
br label %45
43: ; preds = %0
%44 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0))
br label %45
45: ; preds = %43, %41
%46 = call i32* @fopen(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%47 = icmp eq i32* %46, null
br i1 %47, label %64, label %48
48: ; preds = %45, %48
%49 = phi i64 [ %60, %48 ], [ 0, %45 ]
%50 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %49, i64 0
%51 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %49, i64 1
%52 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %49, i64 2
%53 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %49, i64 3
%54 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %49, i64 4
%55 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %49, i64 5
%56 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %49, i64 6
%57 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %49, i64 7
%58 = getelementptr inbounds [168 x double], [168 x double]* %6, i64 0, i64 %49
%59 = call i32 @fscanf(i32* %46, i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.2, i64 0, i64 0), double* %50, double* %51, double* %52, double* %53, double* %54, double* %55, double* %56, double* %57, double* %58)
%60 = add nuw nsw i64 %49, 1
%61 = icmp eq i64 %60, 168
br i1 %61, label %62, label %48
62: ; preds = %48
%63 = call i32 @fclose(i32* %46)
br label %66
64: ; preds = %45
%65 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0))
br label %66
66: ; preds = %64, %62
br label %67
67: ; preds = %67, %66
%68 = phi i64 [ 0, %66 ], [ %93, %67 ]
%69 = phi double [ 0.000000e+00, %66 ], [ %92, %67 ]
%70 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %68, i64 0
%71 = load double, double* %70
%72 = fadd double %69, %71
%73 = or i64 %68, 1
%74 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %73, i64 0
%75 = load double, double* %74
%76 = fadd double %72, %75
%77 = add nuw nsw i64 %68, 2
%78 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %77, i64 0
%79 = load double, double* %78
%80 = fadd double %76, %79
%81 = add nuw nsw i64 %68, 3
%82 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %81, i64 0
%83 = load double, double* %82
%84 = fadd double %80, %83
%85 = add nuw nsw i64 %68, 4
%86 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %85, i64 0
%87 = load double, double* %86
%88 = fadd double %84, %87
%89 = add nuw nsw i64 %68, 5
%90 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %89, i64 0
%91 = load double, double* %90
%92 = fadd double %88, %91
%93 = add nuw nsw i64 %68, 6
%94 = icmp eq i64 %93, 600
br i1 %94, label %95, label %67
95: ; preds = %67
%96 = fdiv double %92, 6.000000e+02
br label %97
97: ; preds = %97, %95
%98 = phi i64 [ 0, %95 ], [ %123, %97 ]
%99 = phi double [ 0.000000e+00, %95 ], [ %122, %97 ]
%100 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %98, i64 1
%101 = load double, double* %100
%102 = fadd double %99, %101
%103 = or i64 %98, 1
%104 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %103, i64 1
%105 = load double, double* %104
%106 = fadd double %102, %105
%107 = add nuw nsw i64 %98, 2
%108 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %107, i64 1
%109 = load double, double* %108
%110 = fadd double %106, %109
%111 = add nuw nsw i64 %98, 3
%112 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %111, i64 1
%113 = load double, double* %112
%114 = fadd double %110, %113
%115 = add nuw nsw i64 %98, 4
%116 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %115, i64 1
%117 = load double, double* %116
%118 = fadd double %114, %117
%119 = add nuw nsw i64 %98, 5
%120 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %119, i64 1
%121 = load double, double* %120
%122 = fadd double %118, %121
%123 = add nuw nsw i64 %98, 6
%124 = icmp eq i64 %123, 600
br i1 %124, label %125, label %97
125: ; preds = %97
%126 = fdiv double %122, 6.000000e+02
br label %127
127: ; preds = %127, %125
%128 = phi i64 [ 0, %125 ], [ %153, %127 ]
%129 = phi double [ 0.000000e+00, %125 ], [ %152, %127 ]
%130 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %128, i64 2
%131 = load double, double* %130
%132 = fadd double %129, %131
%133 = or i64 %128, 1
%134 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %133, i64 2
%135 = load double, double* %134
%136 = fadd double %132, %135
%137 = add nuw nsw i64 %128, 2
%138 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %137, i64 2
%139 = load double, double* %138
%140 = fadd double %136, %139
%141 = add nuw nsw i64 %128, 3
%142 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %141, i64 2
%143 = load double, double* %142
%144 = fadd double %140, %143
%145 = add nuw nsw i64 %128, 4
%146 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %145, i64 2
%147 = load double, double* %146
%148 = fadd double %144, %147
%149 = add nuw nsw i64 %128, 5
%150 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %149, i64 2
%151 = load double, double* %150
%152 = fadd double %148, %151
%153 = add nuw nsw i64 %128, 6
%154 = icmp eq i64 %153, 600
br i1 %154, label %155, label %127
155: ; preds = %127
%156 = fdiv double %152, 6.000000e+02
br label %157
157: ; preds = %157, %155
%158 = phi i64 [ 0, %155 ], [ %183, %157 ]
%159 = phi double [ 0.000000e+00, %155 ], [ %182, %157 ]
%160 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %158, i64 3
%161 = load double, double* %160
%162 = fadd double %159, %161
%163 = or i64 %158, 1
%164 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %163, i64 3
%165 = load double, double* %164
%166 = fadd double %162, %165
%167 = add nuw nsw i64 %158, 2
%168 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %167, i64 3
%169 = load double, double* %168
%170 = fadd double %166, %169
%171 = add nuw nsw i64 %158, 3
%172 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %171, i64 3
%173 = load double, double* %172
%174 = fadd double %170, %173
%175 = add nuw nsw i64 %158, 4
%176 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %175, i64 3
%177 = load double, double* %176
%178 = fadd double %174, %177
%179 = add nuw nsw i64 %158, 5
%180 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %179, i64 3
%181 = load double, double* %180
%182 = fadd double %178, %181
%183 = add nuw nsw i64 %158, 6
%184 = icmp eq i64 %183, 600
br i1 %184, label %185, label %157
185: ; preds = %157
%186 = fdiv double %182, 6.000000e+02
br label %187
187: ; preds = %187, %185
%188 = phi i64 [ 0, %185 ], [ %213, %187 ]
%189 = phi double [ 0.000000e+00, %185 ], [ %212, %187 ]
%190 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %188, i64 4
%191 = load double, double* %190
%192 = fadd double %189, %191
%193 = or i64 %188, 1
%194 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %193, i64 4
%195 = load double, double* %194
%196 = fadd double %192, %195
%197 = add nuw nsw i64 %188, 2
%198 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %197, i64 4
%199 = load double, double* %198
%200 = fadd double %196, %199
%201 = add nuw nsw i64 %188, 3
%202 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %201, i64 4
%203 = load double, double* %202
%204 = fadd double %200, %203
%205 = add nuw nsw i64 %188, 4
%206 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %205, i64 4
%207 = load double, double* %206
%208 = fadd double %204, %207
%209 = add nuw nsw i64 %188, 5
%210 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %209, i64 4
%211 = load double, double* %210
%212 = fadd double %208, %211
%213 = add nuw nsw i64 %188, 6
%214 = icmp eq i64 %213, 600
br i1 %214, label %215, label %187
215: ; preds = %187
%216 = fdiv double %212, 6.000000e+02
br label %217
217: ; preds = %217, %215
%218 = phi i64 [ 0, %215 ], [ %243, %217 ]
%219 = phi double [ 0.000000e+00, %215 ], [ %242, %217 ]
%220 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %218, i64 5
%221 = load double, double* %220
%222 = fadd double %219, %221
%223 = or i64 %218, 1
%224 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %223, i64 5
%225 = load double, double* %224
%226 = fadd double %222, %225
%227 = add nuw nsw i64 %218, 2
%228 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %227, i64 5
%229 = load double, double* %228
%230 = fadd double %226, %229
%231 = add nuw nsw i64 %218, 3
%232 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %231, i64 5
%233 = load double, double* %232
%234 = fadd double %230, %233
%235 = add nuw nsw i64 %218, 4
%236 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %235, i64 5
%237 = load double, double* %236
%238 = fadd double %234, %237
%239 = add nuw nsw i64 %218, 5
%240 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %239, i64 5
%241 = load double, double* %240
%242 = fadd double %238, %241
%243 = add nuw nsw i64 %218, 6
%244 = icmp eq i64 %243, 600
br i1 %244, label %245, label %217
245: ; preds = %217
%246 = fdiv double %242, 6.000000e+02
br label %247
247: ; preds = %247, %245
%248 = phi i64 [ 0, %245 ], [ %273, %247 ]
%249 = phi double [ 0.000000e+00, %245 ], [ %272, %247 ]
%250 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %248, i64 6
%251 = load double, double* %250
%252 = fadd double %249, %251
%253 = or i64 %248, 1
%254 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %253, i64 6
%255 = load double, double* %254
%256 = fadd double %252, %255
%257 = add nuw nsw i64 %248, 2
%258 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %257, i64 6
%259 = load double, double* %258
%260 = fadd double %256, %259
%261 = add nuw nsw i64 %248, 3
%262 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %261, i64 6
%263 = load double, double* %262
%264 = fadd double %260, %263
%265 = add nuw nsw i64 %248, 4
%266 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %265, i64 6
%267 = load double, double* %266
%268 = fadd double %264, %267
%269 = add nuw nsw i64 %248, 5
%270 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %269, i64 6
%271 = load double, double* %270
%272 = fadd double %268, %271
%273 = add nuw nsw i64 %248, 6
%274 = icmp eq i64 %273, 600
br i1 %274, label %275, label %247
275: ; preds = %247
%276 = fdiv double %272, 6.000000e+02
br label %277
277: ; preds = %277, %275
%278 = phi i64 [ 0, %275 ], [ %303, %277 ]
%279 = phi double [ 0.000000e+00, %275 ], [ %302, %277 ]
%280 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %278, i64 7
%281 = load double, double* %280
%282 = fadd double %279, %281
%283 = or i64 %278, 1
%284 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %283, i64 7
%285 = load double, double* %284
%286 = fadd double %282, %285
%287 = add nuw nsw i64 %278, 2
%288 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %287, i64 7
%289 = load double, double* %288
%290 = fadd double %286, %289
%291 = add nuw nsw i64 %278, 3
%292 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %291, i64 7
%293 = load double, double* %292
%294 = fadd double %290, %293
%295 = add nuw nsw i64 %278, 4
%296 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %295, i64 7
%297 = load double, double* %296
%298 = fadd double %294, %297
%299 = add nuw nsw i64 %278, 5
%300 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %299, i64 7
%301 = load double, double* %300
%302 = fadd double %298, %301
%303 = add nuw nsw i64 %278, 6
%304 = icmp eq i64 %303, 600
br i1 %304, label %305, label %277
305: ; preds = %277
%306 = fdiv double %302, 6.000000e+02
%307 = insertelement <2 x double> poison, double %96, i64 0
%308 = shufflevector <2 x double> %307, <2 x double> poison, <2 x i32> zeroinitializer
br label %309
309: ; preds = %309, %305
%310 = phi i64 [ 0, %305 ], [ %322, %309 ]
%311 = or i64 %310, 1
%312 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %310, i64 0
%313 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %311, i64 0
%314 = load double, double* %312
%315 = load double, double* %313
%316 = insertelement <2 x double> poison, double %314, i64 0
%317 = insertelement <2 x double> %316, double %315, i64 1
%318 = fsub <2 x double> %317, %308
%319 = fdiv <2 x double> %318, <double 6.000000e+02, double 6.000000e+02>
%320 = extractelement <2 x double> %319, i64 0
store double %320, double* %312
%321 = extractelement <2 x double> %319, i64 1
store double %321, double* %313
%322 = add nuw i64 %310, 2
%323 = icmp eq i64 %322, 598
br i1 %323, label %324, label %309
324: ; preds = %309
%325 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 598, i64 0
%326 = load double, double* %325
%327 = fsub double %326, %96
%328 = fdiv double %327, 6.000000e+02
store double %328, double* %325
%329 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 599, i64 0
%330 = load double, double* %329
%331 = fsub double %330, %96
%332 = fdiv double %331, 6.000000e+02
store double %332, double* %329
%333 = insertelement <2 x double> poison, double %126, i64 0
%334 = shufflevector <2 x double> %333, <2 x double> poison, <2 x i32> zeroinitializer
br label %335
335: ; preds = %335, %324
%336 = phi i64 [ 0, %324 ], [ %348, %335 ]
%337 = or i64 %336, 1
%338 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %336, i64 1
%339 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %337, i64 1
%340 = load double, double* %338
%341 = load double, double* %339
%342 = insertelement <2 x double> poison, double %340, i64 0
%343 = insertelement <2 x double> %342, double %341, i64 1
%344 = fsub <2 x double> %343, %334
%345 = fdiv <2 x double> %344, <double 6.000000e+02, double 6.000000e+02>
%346 = extractelement <2 x double> %345, i64 0
store double %346, double* %338
%347 = extractelement <2 x double> %345, i64 1
store double %347, double* %339
%348 = add nuw i64 %336, 2
%349 = icmp eq i64 %348, 598
br i1 %349, label %350, label %335
350: ; preds = %335
%351 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 598, i64 1
%352 = load double, double* %351
%353 = fsub double %352, %126
%354 = fdiv double %353, 6.000000e+02
store double %354, double* %351
%355 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 599, i64 1
%356 = load double, double* %355
%357 = fsub double %356, %126
%358 = fdiv double %357, 6.000000e+02
store double %358, double* %355
%359 = insertelement <2 x double> poison, double %156, i64 0
%360 = shufflevector <2 x double> %359, <2 x double> poison, <2 x i32> zeroinitializer
br label %361
361: ; preds = %361, %350
%362 = phi i64 [ 0, %350 ], [ %374, %361 ]
%363 = or i64 %362, 1
%364 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %362, i64 2
%365 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %363, i64 2
%366 = load double, double* %364
%367 = load double, double* %365
%368 = insertelement <2 x double> poison, double %366, i64 0
%369 = insertelement <2 x double> %368, double %367, i64 1
%370 = fsub <2 x double> %369, %360
%371 = fdiv <2 x double> %370, <double 6.000000e+02, double 6.000000e+02>
%372 = extractelement <2 x double> %371, i64 0
store double %372, double* %364
%373 = extractelement <2 x double> %371, i64 1
store double %373, double* %365
%374 = add nuw i64 %362, 2
%375 = icmp eq i64 %374, 598
br i1 %375, label %376, label %361
376: ; preds = %361
%377 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 598, i64 2
%378 = load double, double* %377
%379 = fsub double %378, %156
%380 = fdiv double %379, 6.000000e+02
store double %380, double* %377
%381 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 599, i64 2
%382 = load double, double* %381
%383 = fsub double %382, %156
%384 = fdiv double %383, 6.000000e+02
store double %384, double* %381
%385 = insertelement <2 x double> poison, double %186, i64 0
%386 = shufflevector <2 x double> %385, <2 x double> poison, <2 x i32> zeroinitializer
br label %387
387: ; preds = %387, %376
%388 = phi i64 [ 0, %376 ], [ %400, %387 ]
%389 = or i64 %388, 1
%390 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %388, i64 3
%391 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %389, i64 3
%392 = load double, double* %390
%393 = load double, double* %391
%394 = insertelement <2 x double> poison, double %392, i64 0
%395 = insertelement <2 x double> %394, double %393, i64 1
%396 = fsub <2 x double> %395, %386
%397 = fdiv <2 x double> %396, <double 6.000000e+02, double 6.000000e+02>
%398 = extractelement <2 x double> %397, i64 0
store double %398, double* %390
%399 = extractelement <2 x double> %397, i64 1
store double %399, double* %391
%400 = add nuw i64 %388, 2
%401 = icmp eq i64 %400, 598
br i1 %401, label %402, label %387
402: ; preds = %387
%403 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 598, i64 3
%404 = load double, double* %403
%405 = fsub double %404, %186
%406 = fdiv double %405, 6.000000e+02
store double %406, double* %403
%407 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 599, i64 3
%408 = load double, double* %407
%409 = fsub double %408, %186
%410 = fdiv double %409, 6.000000e+02
store double %410, double* %407
%411 = insertelement <2 x double> poison, double %216, i64 0
%412 = shufflevector <2 x double> %411, <2 x double> poison, <2 x i32> zeroinitializer
br label %413
413: ; preds = %413, %402
%414 = phi i64 [ 0, %402 ], [ %426, %413 ]
%415 = or i64 %414, 1
%416 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %414, i64 4
%417 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %415, i64 4
%418 = load double, double* %416
%419 = load double, double* %417
%420 = insertelement <2 x double> poison, double %418, i64 0
%421 = insertelement <2 x double> %420, double %419, i64 1
%422 = fsub <2 x double> %421, %412
%423 = fdiv <2 x double> %422, <double 6.000000e+02, double 6.000000e+02>
%424 = extractelement <2 x double> %423, i64 0
store double %424, double* %416
%425 = extractelement <2 x double> %423, i64 1
store double %425, double* %417
%426 = add nuw i64 %414, 2
%427 = icmp eq i64 %426, 598
br i1 %427, label %428, label %413
428: ; preds = %413
%429 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 598, i64 4
%430 = load double, double* %429
%431 = fsub double %430, %216
%432 = fdiv double %431, 6.000000e+02
store double %432, double* %429
%433 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 599, i64 4
%434 = load double, double* %433
%435 = fsub double %434, %216
%436 = fdiv double %435, 6.000000e+02
store double %436, double* %433
%437 = insertelement <2 x double> poison, double %246, i64 0
%438 = shufflevector <2 x double> %437, <2 x double> poison, <2 x i32> zeroinitializer
br label %439
439: ; preds = %439, %428
%440 = phi i64 [ 0, %428 ], [ %452, %439 ]
%441 = or i64 %440, 1
%442 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %440, i64 5
%443 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %441, i64 5
%444 = load double, double* %442
%445 = load double, double* %443
%446 = insertelement <2 x double> poison, double %444, i64 0
%447 = insertelement <2 x double> %446, double %445, i64 1
%448 = fsub <2 x double> %447, %438
%449 = fdiv <2 x double> %448, <double 6.000000e+02, double 6.000000e+02>
%450 = extractelement <2 x double> %449, i64 0
store double %450, double* %442
%451 = extractelement <2 x double> %449, i64 1
store double %451, double* %443
%452 = add nuw i64 %440, 2
%453 = icmp eq i64 %452, 598
br i1 %453, label %454, label %439
454: ; preds = %439
%455 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 598, i64 5
%456 = load double, double* %455
%457 = fsub double %456, %246
%458 = fdiv double %457, 6.000000e+02
store double %458, double* %455
%459 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 599, i64 5
%460 = load double, double* %459
%461 = fsub double %460, %246
%462 = fdiv double %461, 6.000000e+02
store double %462, double* %459
%463 = insertelement <2 x double> poison, double %276, i64 0
%464 = shufflevector <2 x double> %463, <2 x double> poison, <2 x i32> zeroinitializer
br label %465
465: ; preds = %465, %454
%466 = phi i64 [ 0, %454 ], [ %478, %465 ]
%467 = or i64 %466, 1
%468 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %466, i64 6
%469 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %467, i64 6
%470 = load double, double* %468
%471 = load double, double* %469
%472 = insertelement <2 x double> poison, double %470, i64 0
%473 = insertelement <2 x double> %472, double %471, i64 1
%474 = fsub <2 x double> %473, %464
%475 = fdiv <2 x double> %474, <double 6.000000e+02, double 6.000000e+02>
%476 = extractelement <2 x double> %475, i64 0
store double %476, double* %468
%477 = extractelement <2 x double> %475, i64 1
store double %477, double* %469
%478 = add nuw i64 %466, 2
%479 = icmp eq i64 %478, 598
br i1 %479, label %480, label %465
480: ; preds = %465
%481 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 598, i64 6
%482 = load double, double* %481
%483 = fsub double %482, %276
%484 = fdiv double %483, 6.000000e+02
store double %484, double* %481
%485 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 599, i64 6
%486 = load double, double* %485
%487 = fsub double %486, %276
%488 = fdiv double %487, 6.000000e+02
store double %488, double* %485
%489 = insertelement <2 x double> poison, double %306, i64 0
%490 = shufflevector <2 x double> %489, <2 x double> poison, <2 x i32> zeroinitializer
br label %491
491: ; preds = %491, %480
%492 = phi i64 [ 0, %480 ], [ %504, %491 ]
%493 = or i64 %492, 1
%494 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %492, i64 7
%495 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %493, i64 7
%496 = load double, double* %494
%497 = load double, double* %495
%498 = insertelement <2 x double> poison, double %496, i64 0
%499 = insertelement <2 x double> %498, double %497, i64 1
%500 = fsub <2 x double> %499, %490
%501 = fdiv <2 x double> %500, <double 6.000000e+02, double 6.000000e+02>
%502 = extractelement <2 x double> %501, i64 0
store double %502, double* %494
%503 = extractelement <2 x double> %501, i64 1
store double %503, double* %495
%504 = add nuw i64 %492, 2
%505 = icmp eq i64 %504, 598
br i1 %505, label %506, label %491
506: ; preds = %491
%507 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 598, i64 7
%508 = load double, double* %507
%509 = fsub double %508, %306
%510 = fdiv double %509, 6.000000e+02
store double %510, double* %507
%511 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 599, i64 7
%512 = load double, double* %511
%513 = fsub double %512, %306
%514 = fdiv double %513, 6.000000e+02
store double %514, double* %511
br label %515
515: ; preds = %515, %506
%516 = phi i64 [ 0, %506 ], [ %541, %515 ]
%517 = phi double [ 0.000000e+00, %506 ], [ %540, %515 ]
%518 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %516, i64 0
%519 = load double, double* %518
%520 = fadd double %517, %519
%521 = or i64 %516, 1
%522 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %521, i64 0
%523 = load double, double* %522
%524 = fadd double %520, %523
%525 = add nuw nsw i64 %516, 2
%526 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %525, i64 0
%527 = load double, double* %526
%528 = fadd double %524, %527
%529 = add nuw nsw i64 %516, 3
%530 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %529, i64 0
%531 = load double, double* %530
%532 = fadd double %528, %531
%533 = add nuw nsw i64 %516, 4
%534 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %533, i64 0
%535 = load double, double* %534
%536 = fadd double %532, %535
%537 = add nuw nsw i64 %516, 5
%538 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %537, i64 0
%539 = load double, double* %538
%540 = fadd double %536, %539
%541 = add nuw nsw i64 %516, 6
%542 = icmp eq i64 %541, 168
br i1 %542, label %543, label %515
543: ; preds = %515
%544 = fdiv double %540, 1.680000e+02
%545 = getelementptr inbounds [8 x double], [8 x double]* %11, i64 0, i64 0
store double %544, double* %545
br label %546
546: ; preds = %546, %543
%547 = phi i64 [ 0, %543 ], [ %572, %546 ]
%548 = phi double [ 0.000000e+00, %543 ], [ %571, %546 ]
%549 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %547, i64 1
%550 = load double, double* %549
%551 = fadd double %548, %550
%552 = or i64 %547, 1
%553 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %552, i64 1
%554 = load double, double* %553
%555 = fadd double %551, %554
%556 = add nuw nsw i64 %547, 2
%557 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %556, i64 1
%558 = load double, double* %557
%559 = fadd double %555, %558
%560 = add nuw nsw i64 %547, 3
%561 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %560, i64 1
%562 = load double, double* %561
%563 = fadd double %559, %562
%564 = add nuw nsw i64 %547, 4
%565 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %564, i64 1
%566 = load double, double* %565
%567 = fadd double %563, %566
%568 = add nuw nsw i64 %547, 5
%569 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %568, i64 1
%570 = load double, double* %569
%571 = fadd double %567, %570
%572 = add nuw nsw i64 %547, 6
%573 = icmp eq i64 %572, 168
br i1 %573, label %574, label %546
574: ; preds = %546
%575 = fdiv double %571, 1.680000e+02
%576 = getelementptr inbounds [8 x double], [8 x double]* %11, i64 0, i64 1
store double %575, double* %576
br label %577
577: ; preds = %577, %574
%578 = phi i64 [ 0, %574 ], [ %603, %577 ]
%579 = phi double [ 0.000000e+00, %574 ], [ %602, %577 ]
%580 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %578, i64 2
%581 = load double, double* %580
%582 = fadd double %579, %581
%583 = or i64 %578, 1
%584 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %583, i64 2
%585 = load double, double* %584
%586 = fadd double %582, %585
%587 = add nuw nsw i64 %578, 2
%588 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %587, i64 2
%589 = load double, double* %588
%590 = fadd double %586, %589
%591 = add nuw nsw i64 %578, 3
%592 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %591, i64 2
%593 = load double, double* %592
%594 = fadd double %590, %593
%595 = add nuw nsw i64 %578, 4
%596 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %595, i64 2
%597 = load double, double* %596
%598 = fadd double %594, %597
%599 = add nuw nsw i64 %578, 5
%600 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %599, i64 2
%601 = load double, double* %600
%602 = fadd double %598, %601
%603 = add nuw nsw i64 %578, 6
%604 = icmp eq i64 %603, 168
br i1 %604, label %605, label %577
605: ; preds = %577
%606 = fdiv double %602, 1.680000e+02
%607 = getelementptr inbounds [8 x double], [8 x double]* %11, i64 0, i64 2
store double %606, double* %607
br label %608
608: ; preds = %608, %605
%609 = phi i64 [ 0, %605 ], [ %634, %608 ]
%610 = phi double [ 0.000000e+00, %605 ], [ %633, %608 ]
%611 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %609, i64 3
%612 = load double, double* %611
%613 = fadd double %610, %612
%614 = or i64 %609, 1
%615 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %614, i64 3
%616 = load double, double* %615
%617 = fadd double %613, %616
%618 = add nuw nsw i64 %609, 2
%619 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %618, i64 3
%620 = load double, double* %619
%621 = fadd double %617, %620
%622 = add nuw nsw i64 %609, 3
%623 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %622, i64 3
%624 = load double, double* %623
%625 = fadd double %621, %624
%626 = add nuw nsw i64 %609, 4
%627 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %626, i64 3
%628 = load double, double* %627
%629 = fadd double %625, %628
%630 = add nuw nsw i64 %609, 5
%631 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %630, i64 3
%632 = load double, double* %631
%633 = fadd double %629, %632
%634 = add nuw nsw i64 %609, 6
%635 = icmp eq i64 %634, 168
br i1 %635, label %636, label %608
636: ; preds = %608
%637 = fdiv double %633, 1.680000e+02
%638 = getelementptr inbounds [8 x double], [8 x double]* %11, i64 0, i64 3
store double %637, double* %638
br label %639
639: ; preds = %639, %636
%640 = phi i64 [ 0, %636 ], [ %665, %639 ]
%641 = phi double [ 0.000000e+00, %636 ], [ %664, %639 ]
%642 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %640, i64 4
%643 = load double, double* %642
%644 = fadd double %641, %643
%645 = or i64 %640, 1
%646 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %645, i64 4
%647 = load double, double* %646
%648 = fadd double %644, %647
%649 = add nuw nsw i64 %640, 2
%650 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %649, i64 4
%651 = load double, double* %650
%652 = fadd double %648, %651
%653 = add nuw nsw i64 %640, 3
%654 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %653, i64 4
%655 = load double, double* %654
%656 = fadd double %652, %655
%657 = add nuw nsw i64 %640, 4
%658 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %657, i64 4
%659 = load double, double* %658
%660 = fadd double %656, %659
%661 = add nuw nsw i64 %640, 5
%662 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %661, i64 4
%663 = load double, double* %662
%664 = fadd double %660, %663
%665 = add nuw nsw i64 %640, 6
%666 = icmp eq i64 %665, 168
br i1 %666, label %667, label %639
667: ; preds = %639
%668 = fdiv double %664, 1.680000e+02
%669 = getelementptr inbounds [8 x double], [8 x double]* %11, i64 0, i64 4
store double %668, double* %669
br label %670
670: ; preds = %670, %667
%671 = phi i64 [ 0, %667 ], [ %696, %670 ]
%672 = phi double [ 0.000000e+00, %667 ], [ %695, %670 ]
%673 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %671, i64 5
%674 = load double, double* %673
%675 = fadd double %672, %674
%676 = or i64 %671, 1
%677 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %676, i64 5
%678 = load double, double* %677
%679 = fadd double %675, %678
%680 = add nuw nsw i64 %671, 2
%681 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %680, i64 5
%682 = load double, double* %681
%683 = fadd double %679, %682
%684 = add nuw nsw i64 %671, 3
%685 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %684, i64 5
%686 = load double, double* %685
%687 = fadd double %683, %686
%688 = add nuw nsw i64 %671, 4
%689 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %688, i64 5
%690 = load double, double* %689
%691 = fadd double %687, %690
%692 = add nuw nsw i64 %671, 5
%693 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %692, i64 5
%694 = load double, double* %693
%695 = fadd double %691, %694
%696 = add nuw nsw i64 %671, 6
%697 = icmp eq i64 %696, 168
br i1 %697, label %698, label %670
698: ; preds = %670
%699 = fdiv double %695, 1.680000e+02
%700 = getelementptr inbounds [8 x double], [8 x double]* %11, i64 0, i64 5
store double %699, double* %700
br label %701
701: ; preds = %701, %698
%702 = phi i64 [ 0, %698 ], [ %727, %701 ]
%703 = phi double [ 0.000000e+00, %698 ], [ %726, %701 ]
%704 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %702, i64 6
%705 = load double, double* %704
%706 = fadd double %703, %705
%707 = or i64 %702, 1
%708 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %707, i64 6
%709 = load double, double* %708
%710 = fadd double %706, %709
%711 = add nuw nsw i64 %702, 2
%712 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %711, i64 6
%713 = load double, double* %712
%714 = fadd double %710, %713
%715 = add nuw nsw i64 %702, 3
%716 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %715, i64 6
%717 = load double, double* %716
%718 = fadd double %714, %717
%719 = add nuw nsw i64 %702, 4
%720 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %719, i64 6
%721 = load double, double* %720
%722 = fadd double %718, %721
%723 = add nuw nsw i64 %702, 5
%724 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %723, i64 6
%725 = load double, double* %724
%726 = fadd double %722, %725
%727 = add nuw nsw i64 %702, 6
%728 = icmp eq i64 %727, 168
br i1 %728, label %729, label %701
729: ; preds = %701
%730 = fdiv double %726, 1.680000e+02
%731 = getelementptr inbounds [8 x double], [8 x double]* %11, i64 0, i64 6
store double %730, double* %731
br label %732
732: ; preds = %732, %729
%733 = phi i64 [ 0, %729 ], [ %758, %732 ]
%734 = phi double [ 0.000000e+00, %729 ], [ %757, %732 ]
%735 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %733, i64 7
%736 = load double, double* %735
%737 = fadd double %734, %736
%738 = or i64 %733, 1
%739 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %738, i64 7
%740 = load double, double* %739
%741 = fadd double %737, %740
%742 = add nuw nsw i64 %733, 2
%743 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %742, i64 7
%744 = load double, double* %743
%745 = fadd double %741, %744
%746 = add nuw nsw i64 %733, 3
%747 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %746, i64 7
%748 = load double, double* %747
%749 = fadd double %745, %748
%750 = add nuw nsw i64 %733, 4
%751 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %750, i64 7
%752 = load double, double* %751
%753 = fadd double %749, %752
%754 = add nuw nsw i64 %733, 5
%755 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %754, i64 7
%756 = load double, double* %755
%757 = fadd double %753, %756
%758 = add nuw nsw i64 %733, 6
%759 = icmp eq i64 %758, 168
br i1 %759, label %760, label %732
760: ; preds = %732
%761 = fdiv double %757, 1.680000e+02
%762 = getelementptr inbounds [8 x double], [8 x double]* %11, i64 0, i64 7
store double %761, double* %762
%763 = insertelement <2 x double> poison, double %544, i64 0
%764 = shufflevector <2 x double> %763, <2 x double> poison, <2 x i32> zeroinitializer
br label %765
765: ; preds = %765, %760
%766 = phi i64 [ 0, %760 ], [ %778, %765 ]
%767 = or i64 %766, 1
%768 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %766, i64 0
%769 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %767, i64 0
%770 = load double, double* %768
%771 = load double, double* %769
%772 = insertelement <2 x double> poison, double %770, i64 0
%773 = insertelement <2 x double> %772, double %771, i64 1
%774 = fsub <2 x double> %773, %764
%775 = fdiv <2 x double> %774, <double 1.680000e+02, double 1.680000e+02>
%776 = extractelement <2 x double> %775, i64 0
store double %776, double* %768
%777 = extractelement <2 x double> %775, i64 1
store double %777, double* %769
%778 = add nuw i64 %766, 2
%779 = icmp eq i64 %778, 166
br i1 %779, label %780, label %765
780: ; preds = %765
%781 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 166, i64 0
%782 = load double, double* %781
%783 = fsub double %782, %544
%784 = fdiv double %783, 1.680000e+02
store double %784, double* %781
%785 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 167, i64 0
%786 = load double, double* %785
%787 = fsub double %786, %544
%788 = fdiv double %787, 1.680000e+02
store double %788, double* %785
%789 = insertelement <2 x double> poison, double %575, i64 0
%790 = shufflevector <2 x double> %789, <2 x double> poison, <2 x i32> zeroinitializer
br label %791
791: ; preds = %791, %780
%792 = phi i64 [ 0, %780 ], [ %804, %791 ]
%793 = or i64 %792, 1
%794 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %792, i64 1
%795 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %793, i64 1
%796 = load double, double* %794
%797 = load double, double* %795
%798 = insertelement <2 x double> poison, double %796, i64 0
%799 = insertelement <2 x double> %798, double %797, i64 1
%800 = fsub <2 x double> %799, %790
%801 = fdiv <2 x double> %800, <double 1.680000e+02, double 1.680000e+02>
%802 = extractelement <2 x double> %801, i64 0
store double %802, double* %794
%803 = extractelement <2 x double> %801, i64 1
store double %803, double* %795
%804 = add nuw i64 %792, 2
%805 = icmp eq i64 %804, 166
br i1 %805, label %806, label %791
806: ; preds = %791
%807 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 166, i64 1
%808 = load double, double* %807
%809 = fsub double %808, %575
%810 = fdiv double %809, 1.680000e+02
store double %810, double* %807
%811 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 167, i64 1
%812 = load double, double* %811
%813 = fsub double %812, %575
%814 = fdiv double %813, 1.680000e+02
store double %814, double* %811
%815 = insertelement <2 x double> poison, double %606, i64 0
%816 = shufflevector <2 x double> %815, <2 x double> poison, <2 x i32> zeroinitializer
br label %817
817: ; preds = %817, %806
%818 = phi i64 [ 0, %806 ], [ %830, %817 ]
%819 = or i64 %818, 1
%820 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %818, i64 2
%821 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %819, i64 2
%822 = load double, double* %820
%823 = load double, double* %821
%824 = insertelement <2 x double> poison, double %822, i64 0
%825 = insertelement <2 x double> %824, double %823, i64 1
%826 = fsub <2 x double> %825, %816
%827 = fdiv <2 x double> %826, <double 1.680000e+02, double 1.680000e+02>
%828 = extractelement <2 x double> %827, i64 0
store double %828, double* %820
%829 = extractelement <2 x double> %827, i64 1
store double %829, double* %821
%830 = add nuw i64 %818, 2
%831 = icmp eq i64 %830, 166
br i1 %831, label %832, label %817
832: ; preds = %817
%833 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 166, i64 2
%834 = load double, double* %833
%835 = fsub double %834, %606
%836 = fdiv double %835, 1.680000e+02
store double %836, double* %833
%837 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 167, i64 2
%838 = load double, double* %837
%839 = fsub double %838, %606
%840 = fdiv double %839, 1.680000e+02
store double %840, double* %837
%841 = insertelement <2 x double> poison, double %637, i64 0
%842 = shufflevector <2 x double> %841, <2 x double> poison, <2 x i32> zeroinitializer
br label %843
843: ; preds = %843, %832
%844 = phi i64 [ 0, %832 ], [ %856, %843 ]
%845 = or i64 %844, 1
%846 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %844, i64 3
%847 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %845, i64 3
%848 = load double, double* %846
%849 = load double, double* %847
%850 = insertelement <2 x double> poison, double %848, i64 0
%851 = insertelement <2 x double> %850, double %849, i64 1
%852 = fsub <2 x double> %851, %842
%853 = fdiv <2 x double> %852, <double 1.680000e+02, double 1.680000e+02>
%854 = extractelement <2 x double> %853, i64 0
store double %854, double* %846
%855 = extractelement <2 x double> %853, i64 1
store double %855, double* %847
%856 = add nuw i64 %844, 2
%857 = icmp eq i64 %856, 166
br i1 %857, label %858, label %843
858: ; preds = %843
%859 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 166, i64 3
%860 = load double, double* %859
%861 = fsub double %860, %637
%862 = fdiv double %861, 1.680000e+02
store double %862, double* %859
%863 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 167, i64 3
%864 = load double, double* %863
%865 = fsub double %864, %637
%866 = fdiv double %865, 1.680000e+02
store double %866, double* %863
%867 = insertelement <2 x double> poison, double %668, i64 0
%868 = shufflevector <2 x double> %867, <2 x double> poison, <2 x i32> zeroinitializer
br label %869
869: ; preds = %869, %858
%870 = phi i64 [ 0, %858 ], [ %882, %869 ]
%871 = or i64 %870, 1
%872 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %870, i64 4
%873 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %871, i64 4
%874 = load double, double* %872
%875 = load double, double* %873
%876 = insertelement <2 x double> poison, double %874, i64 0
%877 = insertelement <2 x double> %876, double %875, i64 1
%878 = fsub <2 x double> %877, %868
%879 = fdiv <2 x double> %878, <double 1.680000e+02, double 1.680000e+02>
%880 = extractelement <2 x double> %879, i64 0
store double %880, double* %872
%881 = extractelement <2 x double> %879, i64 1
store double %881, double* %873
%882 = add nuw i64 %870, 2
%883 = icmp eq i64 %882, 166
br i1 %883, label %884, label %869
884: ; preds = %869
%885 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 166, i64 4
%886 = load double, double* %885
%887 = fsub double %886, %668
%888 = fdiv double %887, 1.680000e+02
store double %888, double* %885
%889 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 167, i64 4
%890 = load double, double* %889
%891 = fsub double %890, %668
%892 = fdiv double %891, 1.680000e+02
store double %892, double* %889
%893 = insertelement <2 x double> poison, double %699, i64 0
%894 = shufflevector <2 x double> %893, <2 x double> poison, <2 x i32> zeroinitializer
br label %895
895: ; preds = %895, %884
%896 = phi i64 [ 0, %884 ], [ %908, %895 ]
%897 = or i64 %896, 1
%898 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %896, i64 5
%899 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %897, i64 5
%900 = load double, double* %898
%901 = load double, double* %899
%902 = insertelement <2 x double> poison, double %900, i64 0
%903 = insertelement <2 x double> %902, double %901, i64 1
%904 = fsub <2 x double> %903, %894
%905 = fdiv <2 x double> %904, <double 1.680000e+02, double 1.680000e+02>
%906 = extractelement <2 x double> %905, i64 0
store double %906, double* %898
%907 = extractelement <2 x double> %905, i64 1
store double %907, double* %899
%908 = add nuw i64 %896, 2
%909 = icmp eq i64 %908, 166
br i1 %909, label %910, label %895
910: ; preds = %895
%911 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 166, i64 5
%912 = load double, double* %911
%913 = fsub double %912, %699
%914 = fdiv double %913, 1.680000e+02
store double %914, double* %911
%915 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 167, i64 5
%916 = load double, double* %915
%917 = fsub double %916, %699
%918 = fdiv double %917, 1.680000e+02
store double %918, double* %915
%919 = insertelement <2 x double> poison, double %730, i64 0
%920 = shufflevector <2 x double> %919, <2 x double> poison, <2 x i32> zeroinitializer
br label %921
921: ; preds = %921, %910
%922 = phi i64 [ 0, %910 ], [ %934, %921 ]
%923 = or i64 %922, 1
%924 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %922, i64 6
%925 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %923, i64 6
%926 = load double, double* %924
%927 = load double, double* %925
%928 = insertelement <2 x double> poison, double %926, i64 0
%929 = insertelement <2 x double> %928, double %927, i64 1
%930 = fsub <2 x double> %929, %920
%931 = fdiv <2 x double> %930, <double 1.680000e+02, double 1.680000e+02>
%932 = extractelement <2 x double> %931, i64 0
store double %932, double* %924
%933 = extractelement <2 x double> %931, i64 1
store double %933, double* %925
%934 = add nuw i64 %922, 2
%935 = icmp eq i64 %934, 166
br i1 %935, label %936, label %921
936: ; preds = %921
%937 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 166, i64 6
%938 = load double, double* %937
%939 = fsub double %938, %730
%940 = fdiv double %939, 1.680000e+02
store double %940, double* %937
%941 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 167, i64 6
%942 = load double, double* %941
%943 = fsub double %942, %730
%944 = fdiv double %943, 1.680000e+02
store double %944, double* %941
%945 = insertelement <2 x double> poison, double %761, i64 0
%946 = shufflevector <2 x double> %945, <2 x double> poison, <2 x i32> zeroinitializer
br label %947
947: ; preds = %947, %936
%948 = phi i64 [ 0, %936 ], [ %960, %947 ]
%949 = or i64 %948, 1
%950 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %948, i64 7
%951 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %949, i64 7
%952 = load double, double* %950
%953 = load double, double* %951
%954 = insertelement <2 x double> poison, double %952, i64 0
%955 = insertelement <2 x double> %954, double %953, i64 1
%956 = fsub <2 x double> %955, %946
%957 = fdiv <2 x double> %956, <double 1.680000e+02, double 1.680000e+02>
%958 = extractelement <2 x double> %957, i64 0
store double %958, double* %950
%959 = extractelement <2 x double> %957, i64 1
store double %959, double* %951
%960 = add nuw i64 %948, 2
%961 = icmp eq i64 %960, 166
br i1 %961, label %962, label %947
962: ; preds = %947
%963 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 166, i64 7
%964 = load double, double* %963
%965 = fsub double %964, %761
%966 = fdiv double %965, 1.680000e+02
store double %966, double* %963
%967 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 167, i64 7
%968 = load double, double* %967
%969 = fsub double %968, %761
%970 = fdiv double %969, 1.680000e+02
store double %970, double* %967
%971 = getelementptr inbounds [8 x double], [8 x double]* %3, i64 0, i64 0
%972 = call i32 @Weights_init(double* %971)
%973 = call i32* @fopen(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
%974 = getelementptr inbounds [600 x double], [600 x double]* %8, i64 0, i64 0
%975 = getelementptr inbounds [600 x double], [600 x double]* %9, i64 0, i64 0
%976 = getelementptr inbounds [600 x double], [600 x double]* %10, i64 0, i64 0
%977 = bitcast [600 x double]* %12 to i8*
%978 = getelementptr inbounds [8 x double], [8 x double]* %3, i64 0, i64 1
%979 = getelementptr inbounds [8 x double], [8 x double]* %3, i64 0, i64 2
%980 = getelementptr inbounds [8 x double], [8 x double]* %3, i64 0, i64 3
%981 = getelementptr inbounds [8 x double], [8 x double]* %3, i64 0, i64 4
%982 = getelementptr inbounds [8 x double], [8 x double]* %3, i64 0, i64 5
%983 = getelementptr inbounds [8 x double], [8 x double]* %3, i64 0, i64 6
%984 = getelementptr inbounds [8 x double], [8 x double]* %3, i64 0, i64 7
br label %985
985: ; preds = %962, %1219
%986 = phi i32 [ 0, %962 ], [ %1220, %1219 ]
%987 = call i32 @reset_parameters(double* %974, double* %975, double* %976)
br label %988
988: ; preds = %985, %988
%989 = phi i64 [ 0, %985 ], [ %1029, %988 ]
%990 = getelementptr inbounds [600 x double], [600 x double]* %8, i64 0, i64 %989
%991 = load double, double* %990
%992 = load double, double* %971
%993 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %989, i64 0
%994 = load double, double* %993
%995 = call double @llvm.fmuladd.f64(double %992, double %994, double %991)
%996 = load double, double* %978
%997 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %989, i64 1
%998 = load double, double* %997
%999 = call double @llvm.fmuladd.f64(double %996, double %998, double %995)
%1000 = load double, double* %979
%1001 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %989, i64 2
%1002 = load double, double* %1001
%1003 = call double @llvm.fmuladd.f64(double %1000, double %1002, double %999)
%1004 = load double, double* %980
%1005 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %989, i64 3
%1006 = load double, double* %1005
%1007 = call double @llvm.fmuladd.f64(double %1004, double %1006, double %1003)
%1008 = load double, double* %981
%1009 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %989, i64 4
%1010 = load double, double* %1009
%1011 = call double @llvm.fmuladd.f64(double %1008, double %1010, double %1007)
%1012 = load double, double* %982
%1013 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %989, i64 5
%1014 = load double, double* %1013
%1015 = call double @llvm.fmuladd.f64(double %1012, double %1014, double %1011)
%1016 = load double, double* %983
%1017 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %989, i64 6
%1018 = load double, double* %1017
%1019 = call double @llvm.fmuladd.f64(double %1016, double %1018, double %1015)
%1020 = load double, double* %984
%1021 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %989, i64 7
%1022 = load double, double* %1021
%1023 = call double @llvm.fmuladd.f64(double %1020, double %1022, double %1019)
%1024 = getelementptr inbounds [600 x double], [600 x double]* %4, i64 0, i64 %989
%1025 = load double, double* %1024
%1026 = fadd double %1025, %1023
store double %1026, double* %990
%1027 = call double @sigmoid(double %1026)
%1028 = getelementptr inbounds [600 x double], [600 x double]* %9, i64 0, i64 %989
store double %1027, double* %1028
%1029 = add nuw nsw i64 %989, 1
%1030 = icmp eq i64 %1029, 600
br i1 %1030, label %1031, label %988
1031: ; preds = %988, %1031
%1032 = phi i64 [ %1051, %1031 ], [ 0, %988 ]
%1033 = phi double [ %1050, %1031 ], [ 0.000000e+00, %988 ]
%1034 = getelementptr inbounds [600 x double], [600 x double]* %2, i64 0, i64 %1032
%1035 = load double, double* %1034
%1036 = getelementptr inbounds [600 x double], [600 x double]* %9, i64 0, i64 %1032
%1037 = load double, double* %1036
%1038 = fptosi double %1037 to i32
%1039 = call i32 @log(i32 %1038)
%1040 = sitofp i32 %1039 to double
%1041 = load double, double* %1034
%1042 = fsub double 1.000000e+00, %1041
%1043 = load double, double* %1036
%1044 = fsub double 1.000000e+00, %1043
%1045 = fptosi double %1044 to i32
%1046 = call i32 @log(i32 %1045)
%1047 = sitofp i32 %1046 to double
%1048 = fmul double %1042, %1047
%1049 = call double @llvm.fmuladd.f64(double %1035, double %1040, double %1048)
%1050 = fsub double %1033, %1049
%1051 = add nuw nsw i64 %1032, 1
%1052 = icmp eq i64 %1051, 600
br i1 %1052, label %1053, label %1031
1053: ; preds = %1031
%1054 = fdiv double %1050, 6.000000e+02
%1055 = urem i32 %986, 1000
%1056 = icmp eq i32 %1055, 0
br i1 %1056, label %1057, label %1059
1057: ; preds = %1053
%1058 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.7, i64 0, i64 0), i32 %986, double %1054)
br label %1059
1059: ; preds = %1057, %1053
%1060 = call i32 @fprintf(i32* %973, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.7, i64 0, i64 0), i32 %986, double %1054)
br label %1061
1061: ; preds = %1061, %1059
%1062 = phi i64 [ 0, %1059 ], [ %1100, %1061 ]
%1063 = getelementptr inbounds [600 x double], [600 x double]* %9, i64 0, i64 %1062
%1064 = bitcast double* %1063 to <2 x double>*
%1065 = load <2 x double>, <2 x double>* %1064
%1066 = getelementptr inbounds double, double* %1063, i64 2
%1067 = bitcast double* %1066 to <2 x double>*
%1068 = load <2 x double>, <2 x double>* %1067
%1069 = getelementptr inbounds [600 x double], [600 x double]* %2, i64 0, i64 %1062
%1070 = bitcast double* %1069 to <2 x double>*
%1071 = load <2 x double>, <2 x double>* %1070
%1072 = getelementptr inbounds double, double* %1069, i64 2
%1073 = bitcast double* %1072 to <2 x double>*
%1074 = load <2 x double>, <2 x double>* %1073
%1075 = fsub <2 x double> %1065, %1071
%1076 = fsub <2 x double> %1068, %1074
%1077 = getelementptr inbounds [600 x double], [600 x double]* %10, i64 0, i64 %1062
%1078 = bitcast double* %1077 to <2 x double>*
store <2 x double> %1075, <2 x double>* %1078
%1079 = getelementptr inbounds double, double* %1077, i64 2
%1080 = bitcast double* %1079 to <2 x double>*
store <2 x double> %1076, <2 x double>* %1080
%1081 = or i64 %1062, 4
%1082 = getelementptr inbounds [600 x double], [600 x double]* %9, i64 0, i64 %1081
%1083 = bitcast double* %1082 to <2 x double>*
%1084 = load <2 x double>, <2 x double>* %1083
%1085 = getelementptr inbounds double, double* %1082, i64 2
%1086 = bitcast double* %1085 to <2 x double>*
%1087 = load <2 x double>, <2 x double>* %1086
%1088 = getelementptr inbounds [600 x double], [600 x double]* %2, i64 0, i64 %1081
%1089 = bitcast double* %1088 to <2 x double>*
%1090 = load <2 x double>, <2 x double>* %1089
%1091 = getelementptr inbounds double, double* %1088, i64 2
%1092 = bitcast double* %1091 to <2 x double>*
%1093 = load <2 x double>, <2 x double>* %1092
%1094 = fsub <2 x double> %1084, %1090
%1095 = fsub <2 x double> %1087, %1093
%1096 = getelementptr inbounds [600 x double], [600 x double]* %10, i64 0, i64 %1081
%1097 = bitcast double* %1096 to <2 x double>*
store <2 x double> %1094, <2 x double>* %1097
%1098 = getelementptr inbounds double, double* %1096, i64 2
%1099 = bitcast double* %1098 to <2 x double>*
store <2 x double> %1095, <2 x double>* %1099
%1100 = add nuw nsw i64 %1062, 8
%1101 = icmp eq i64 %1100, 600
br i1 %1101, label %1102, label %1061
1102: ; preds = %1061, %1216
%1103 = phi i64 [ %1217, %1216 ], [ 0, %1061 ]
br label %1104
1104: ; preds = %1104, %1102
%1105 = phi i64 [ 0, %1102 ], [ %1130, %1104 ]
%1106 = phi double [ 0.000000e+00, %1102 ], [ %1129, %1104 ]
%1107 = getelementptr inbounds [600 x double], [600 x double]* %10, i64 0, i64 %1105
%1108 = load double, double* %1107
%1109 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %1105, i64 %1103
%1110 = load double, double* %1109
%1111 = fmul double %1108, %1110
%1112 = getelementptr inbounds [600 x double], [600 x double]* %12, i64 0, i64 %1105
store double %1111, double* %1112
%1113 = fadd double %1106, %1108
%1114 = add nuw nsw i64 %1105, 1
%1115 = getelementptr inbounds [600 x double], [600 x double]* %10, i64 0, i64 %1114
%1116 = load double, double* %1115
%1117 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %1114, i64 %1103
%1118 = load double, double* %1117
%1119 = fmul double %1116, %1118
%1120 = getelementptr inbounds [600 x double], [600 x double]* %12, i64 0, i64 %1114
store double %1119, double* %1120
%1121 = fadd double %1113, %1116
%1122 = add nuw nsw i64 %1105, 2
%1123 = getelementptr inbounds [600 x double], [600 x double]* %10, i64 0, i64 %1122
%1124 = load double, double* %1123
%1125 = getelementptr inbounds [600 x [8 x double]], [600 x [8 x double]]* %1, i64 0, i64 %1122, i64 %1103
%1126 = load double, double* %1125
%1127 = fmul double %1124, %1126
%1128 = getelementptr inbounds [600 x double], [600 x double]* %12, i64 0, i64 %1122
store double %1127, double* %1128
%1129 = fadd double %1121, %1124
%1130 = add nuw nsw i64 %1105, 3
%1131 = icmp eq i64 %1130, 600
br i1 %1131, label %1132, label %1104
1132: ; preds = %1104, %1132
%1133 = phi i64 [ %1166, %1132 ], [ 0, %1104 ]
%1134 = phi double [ %1165, %1132 ], [ 0.000000e+00, %1104 ]
%1135 = getelementptr inbounds [600 x double], [600 x double]* %12, i64 0, i64 %1133
%1136 = load double, double* %1135
%1137 = fadd double %1134, %1136
%1138 = or i64 %1133, 1
%1139 = getelementptr inbounds [600 x double], [600 x double]* %12, i64 0, i64 %1138
%1140 = load double, double* %1139
%1141 = fadd double %1137, %1140
%1142 = or i64 %1133, 2
%1143 = getelementptr inbounds [600 x double], [600 x double]* %12, i64 0, i64 %1142
%1144 = load double, double* %1143
%1145 = fadd double %1141, %1144
%1146 = or i64 %1133, 3
%1147 = getelementptr inbounds [600 x double], [600 x double]* %12, i64 0, i64 %1146
%1148 = load double, double* %1147
%1149 = fadd double %1145, %1148
%1150 = or i64 %1133, 4
%1151 = getelementptr inbounds [600 x double], [600 x double]* %12, i64 0, i64 %1150
%1152 = load double, double* %1151
%1153 = fadd double %1149, %1152
%1154 = or i64 %1133, 5
%1155 = getelementptr inbounds [600 x double], [600 x double]* %12, i64 0, i64 %1154
%1156 = load double, double* %1155
%1157 = fadd double %1153, %1156
%1158 = or i64 %1133, 6
%1159 = getelementptr inbounds [600 x double], [600 x double]* %12, i64 0, i64 %1158
%1160 = load double, double* %1159
%1161 = fadd double %1157, %1160
%1162 = or i64 %1133, 7
%1163 = getelementptr inbounds [600 x double], [600 x double]* %12, i64 0, i64 %1162
%1164 = load double, double* %1163
%1165 = fadd double %1161, %1164
%1166 = add nuw nsw i64 %1133, 8
%1167 = icmp eq i64 %1166, 600
br i1 %1167, label %1168, label %1132
1168: ; preds = %1132
%1169 = fmul double %1165, 1.000000e-02
%1170 = fdiv double %1169, 6.000000e+02
%1171 = getelementptr inbounds [8 x double], [8 x double]* %3, i64 0, i64 %1103
%1172 = load double, double* %1171
%1173 = fsub double %1172, %1170
store double %1173, double* %1171
%1174 = fmul double %1129, 1.000000e-02
%1175 = fdiv double %1174, 6.000000e+02
%1176 = insertelement <2 x double> poison, double %1175, i64 0
%1177 = shufflevector <2 x double> %1176, <2 x double> poison, <2 x i32> zeroinitializer
%1178 = insertelement <2 x double> poison, double %1175, i64 0
%1179 = shufflevector <2 x double> %1178, <2 x double> poison, <2 x i32> zeroinitializer
br label %1180
1180: ; preds = %1180, %1168
%1181 = phi i64 [ 0, %1168 ], [ %1214, %1180 ]
%1182 = getelementptr inbounds [600 x double], [600 x double]* %4, i64 0, i64 %1181
%1183 = bitcast double* %1182 to <2 x double>*
%1184 = load <2 x double>, <2 x double>* %1183
%1185 = getelementptr inbounds double, double* %1182, i64 2
%1186 = bitcast double* %1185 to <2 x double>*
%1187 = load <2 x double>, <2 x double>* %1186
%1188 = fsub <2 x double> %1184, %1177
%1189 = fsub <2 x double> %1187, %1179
%1190 = bitcast double* %1182 to <2 x double>*
store <2 x double> %1188, <2 x double>* %1190
%1191 = bitcast double* %1185 to <2 x double>*
store <2 x double> %1189, <2 x double>* %1191
%1192 = add nuw nsw i64 %1181, 4
%1193 = getelementptr inbounds [600 x double], [600 x double]* %4, i64 0, i64 %1192
%1194 = bitcast double* %1193 to <2 x double>*
%1195 = load <2 x double>, <2 x double>* %1194
%1196 = getelementptr inbounds double, double* %1193, i64 2
%1197 = bitcast double* %1196 to <2 x double>*
%1198 = load <2 x double>, <2 x double>* %1197
%1199 = fsub <2 x double> %1195, %1177
%1200 = fsub <2 x double> %1198, %1179
%1201 = bitcast double* %1193 to <2 x double>*
store <2 x double> %1199, <2 x double>* %1201
%1202 = bitcast double* %1196 to <2 x double>*
store <2 x double> %1200, <2 x double>* %1202
%1203 = add nuw nsw i64 %1181, 8
%1204 = getelementptr inbounds [600 x double], [600 x double]* %4, i64 0, i64 %1203
%1205 = bitcast double* %1204 to <2 x double>*
%1206 = load <2 x double>, <2 x double>* %1205
%1207 = getelementptr inbounds double, double* %1204, i64 2
%1208 = bitcast double* %1207 to <2 x double>*
%1209 = load <2 x double>, <2 x double>* %1208
%1210 = fsub <2 x double> %1206, %1177
%1211 = fsub <2 x double> %1209, %1179
%1212 = bitcast double* %1204 to <2 x double>*
store <2 x double> %1210, <2 x double>* %1212
%1213 = bitcast double* %1207 to <2 x double>*
store <2 x double> %1211, <2 x double>* %1213
%1214 = add nuw nsw i64 %1181, 12
%1215 = icmp eq i64 %1214, 600
br i1 %1215, label %1216, label %1180
1216: ; preds = %1180
%1217 = add nuw nsw i64 %1103, 1
%1218 = icmp eq i64 %1217, 8
br i1 %1218, label %1219, label %1102
1219: ; preds = %1216
%1220 = add nuw nsw i32 %986, 1
%1221 = icmp eq i32 %1220, 4000
br i1 %1221, label %1222, label %985
1222: ; preds = %1219
%1223 = getelementptr inbounds [8 x double], [8 x double]* %3, i64 0, i64 1
%1224 = getelementptr inbounds [8 x double], [8 x double]* %3, i64 0, i64 2
%1225 = getelementptr inbounds [8 x double], [8 x double]* %3, i64 0, i64 3
%1226 = getelementptr inbounds [8 x double], [8 x double]* %3, i64 0, i64 4
%1227 = getelementptr inbounds [8 x double], [8 x double]* %3, i64 0, i64 5
%1228 = getelementptr inbounds [8 x double], [8 x double]* %3, i64 0, i64 6
%1229 = getelementptr inbounds [8 x double], [8 x double]* %3, i64 0, i64 7
%1230 = call i32 @reset_parameters(double* %974, double* %975, double* %976)
br label %1231
1231: ; preds = %1222, %1231
%1232 = phi i64 [ 0, %1222 ], [ %1272, %1231 ]
%1233 = getelementptr inbounds [600 x double], [600 x double]* %8, i64 0, i64 %1232
%1234 = load double, double* %1233
%1235 = load double, double* %971
%1236 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %1232, i64 0
%1237 = load double, double* %1236
%1238 = call double @llvm.fmuladd.f64(double %1235, double %1237, double %1234)
%1239 = load double, double* %1223
%1240 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %1232, i64 1
%1241 = load double, double* %1240
%1242 = call double @llvm.fmuladd.f64(double %1239, double %1241, double %1238)
%1243 = load double, double* %1224
%1244 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %1232, i64 2
%1245 = load double, double* %1244
%1246 = call double @llvm.fmuladd.f64(double %1243, double %1245, double %1242)
%1247 = load double, double* %1225
%1248 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %1232, i64 3
%1249 = load double, double* %1248
%1250 = call double @llvm.fmuladd.f64(double %1247, double %1249, double %1246)
%1251 = load double, double* %1226
%1252 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %1232, i64 4
%1253 = load double, double* %1252
%1254 = call double @llvm.fmuladd.f64(double %1251, double %1253, double %1250)
%1255 = load double, double* %1227
%1256 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %1232, i64 5
%1257 = load double, double* %1256
%1258 = call double @llvm.fmuladd.f64(double %1255, double %1257, double %1254)
%1259 = load double, double* %1228
%1260 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %1232, i64 6
%1261 = load double, double* %1260
%1262 = call double @llvm.fmuladd.f64(double %1259, double %1261, double %1258)
%1263 = load double, double* %1229
%1264 = getelementptr inbounds [168 x [8 x double]], [168 x [8 x double]]* %5, i64 0, i64 %1232, i64 7
%1265 = load double, double* %1264
%1266 = call double @llvm.fmuladd.f64(double %1263, double %1265, double %1262)
%1267 = getelementptr inbounds [600 x double], [600 x double]* %4, i64 0, i64 %1232
%1268 = load double, double* %1267
%1269 = fadd double %1268, %1266
store double %1269, double* %1233
%1270 = call double @sigmoid(double %1269)
%1271 = getelementptr inbounds [168 x double], [168 x double]* %7, i64 0, i64 %1232
store double %1270, double* %1271
%1272 = add nuw nsw i64 %1232, 1
%1273 = icmp eq i64 %1272, 168
br i1 %1273, label %1274, label %1231
1274: ; preds = %1231, %1284
%1275 = phi i64 [ %1292, %1284 ], [ 0, %1231 ]
%1276 = phi double [ %1290, %1284 ], [ 0.000000e+00, %1231 ]
%1277 = getelementptr inbounds [168 x double], [168 x double]* %7, i64 0, i64 %1275
%1278 = load double, double* %1277
%1279 = fcmp ogt double %1278, 5.000000e-01
br i1 %1279, label %1282, label %1280
1280: ; preds = %1274
%1281 = fcmp olt double %1278, 5.000000e-01
br i1 %1281, label %1282, label %1284
1282: ; preds = %1280, %1274
%1283 = phi double [ 1.000000e+00, %1274 ], [ 0.000000e+00, %1280 ]
store double %1283, double* %1277
br label %1284
1284: ; preds = %1282, %1280
%1285 = phi double [ %1278, %1280 ], [ %1283, %1282 ]
%1286 = getelementptr inbounds [168 x double], [168 x double]* %6, i64 0, i64 %1275
%1287 = load double, double* %1286
%1288 = fcmp oeq double %1285, %1287
%1289 = fadd double %1276, 1.000000e+00
%1290 = select i1 %1288, double %1289, double %1276
%1291 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.8, i64 0, i64 0), double %1287, double %1285)
%1292 = add nuw nsw i64 %1275, 1
%1293 = icmp eq i64 %1292, 168
br i1 %1293, label %1294, label %1274
1294: ; preds = %1284
%1295 = fdiv double %1290, 1.680000e+02
%1296 = fmul double %1295, 1.000000e+02
%1297 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.9, i64 0, i64 0), double %1296)
%1298 = call i32 @export_weights(double* %971, double* %17, double* %545)
%1299 = call i32 @fclose(i32* %973)
ret i32 0
}