int simplex_method(double **T, int no_of_eqns, int no_of_variables, int *column,
                   int *row, int phase, int eqn_type[]) {
  int flag = 0, mp = 0, i;
  double **A;
  int special1 = 0;
  A = (double **)malloc((no_of_eqns + 1) * sizeof(double *));
  for (i = 0; i < no_of_eqns + 1; i++) {
    A[i] = (double *)malloc((no_of_variables + 1) * sizeof(double));
  }
  double min = 100;
  for (i = 0; i < no_of_variables; i++) {
    if (T[no_of_eqns][i] < min && T[no_of_eqns][i] <= 0) {
      flag = 1;
      min = T[no_of_eqns][i];
      mp = i;
    }
  }
  int most_negative_column = mp, pivot_row;
  double most_negative_value = min, pivot_value = 10000;
repeat:
  if (flag == 0) {
    if (phase == 1)
      print_result_phase_I(T, no_of_eqns, no_of_variables, column, row);
    else if (phase == 2)
      print_result_phase_II(T, no_of_eqns, no_of_variables, column, row);
    return 1;
  } else {
    int min_ratio_row = 0;
    double min_ratio = 10000;
    int flag3 = 0;
    for (i = 0; i < no_of_eqns; i++) {
      if (T[i][no_of_variables] / T[i][most_negative_column] < min_ratio &&
          T[i][most_negative_column] > 0) {
        flag3 = 1;
        min_ratio = T[i][no_of_variables] / T[i][most_negative_column];
        min_ratio_row = i;
      }
    }
    if (phase == 2) {
      int j;
      for (j = 0; j < no_of_eqns; j++) {
        if (row[j] / 10 == 2 && eqn_type[row[j] % 10] != 1 &&
            T[j][most_negative_column] < 0) {
          flag3 = 1;
          min_ratio = 0;
          min_ratio_row = j;
          special1 = 1;
        }
      }
    }
    if (flag3 == 0) {
      int k, temp = most_negative_column + 1;
      for (k = temp; k < no_of_variables; k++) {
        if (T[no_of_eqns][k] == 0) {
          most_negative_column = k;
          most_negative_value = 0;
          goto repeat;
        }
      }
      printf("The solution is unbounded\n");
      return 2;
    } else {
      pivot_row = min_ratio_row;
      pivot_value = T[min_ratio_row][most_negative_column];
      int temp1 = row[min_ratio_row];
      row[min_ratio_row] = column[most_negative_column];
      column[most_negative_column] = temp1;
      for (i = 0; i < no_of_eqns + 1; i++) {
        int j;
        for (j = 0; j < no_of_variables + 1; j++) {
          if (i == pivot_row && j == most_negative_column) {
            A[i][j] = 1 / T[i][j];
          } else if (i == pivot_row && j != most_negative_column) {
            A[i][j] = T[i][j] / pivot_value;
          } else if (j == most_negative_column && i != pivot_row) {
            A[i][j] = -T[i][j] / pivot_value;
          } else if (j != most_negative_column && i != pivot_row) {
            double temp = T[i][j] * pivot_value -
                          T[pivot_row][j] * T[i][most_negative_column];
            A[i][j] = temp / ((double)pivot_value);
          }
        }
      }
    }
  }
  for (i = 0; i < no_of_eqns + 1; i++) {
    int j;
    for (j = 0; j < no_of_variables + 1; j++) {
      T[i][j] = A[i][j];
    }
  }
  if (special1 == 1) {
    int cc;
    for (i = 0; i < no_of_variables; i++) {
      if (column[i] / 10 == 2 && eqn_type[column[i] % 10] != 1) {
        cc = i;
        break;
      }
    }
    for (i = 0; i <= no_of_eqns; i++) {
      T[cc][i] = 0;
    }
  }
  printf("\nTable: \n");
  int k, l;
  for (l = 0; l < no_of_variables; l++) {
    if (column[l] / 10 == 1) {
      printf("X%d\t\t", (column[l] % 10) + 1);
    } else if (column[l] / 10 == 2) {
      printf("Z%d\t\t", (column[l] % 10) + 1);
    }
  }
  printf("1\n");
  for (k = 0; k < no_of_eqns + 1; k++) {
    for (l = 0; l < no_of_variables + 1; l++) {
      printf("%lf\t", T[k][l]);
    }
    if (k == no_of_eqns) {
      printf("Z\n");
    } else {
      switch (row[k] / 10) {
      case 1:
        printf("X%d\n", (row[k] % 10) + 1);
        break;
      case 2:
        printf("Z%d\n", (row[k] % 10) + 1);
        break;
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<simplex_method>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    11d7 <simplex_method+0x97>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1197 <simplex_method+0x57>
movsd  0xe21(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1273 <simplex_method+0x133>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x50(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1260 <simplex_method+0x120>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jb     1260 <simplex_method+0x120>
movl   $0x1,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1265 <simplex_method+0x125>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11eb <simplex_method+0xab>
mov    -0x34(%rbp),%eax
mov    %eax,-0x54(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xd7d(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
cmpl   $0x0,-0x30(%rbp)
jne    12f6 <simplex_method+0x1b6>
cmpl   $0x1,-0x2c(%rbp)
jne    12c2 <simplex_method+0x182>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    $0x0,%al
call   1050 <print_result_phase_I@plt>
jmp    12ea <simplex_method+0x1aa>
cmpl   $0x2,-0x2c(%rbp)
jne    12e5 <simplex_method+0x1a5>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    $0x0,%al
call   1060 <print_result_phase_II@plt>
jmp    12ea <simplex_method+0x1aa>
movl   $0x1,-0x4(%rbp)
jmp    1b71 <simplex_method+0xa31>
movl   $0x0,-0x6c(%rbp)
movsd  0xd03(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x7c(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13ce <simplex_method+0x28e>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm1
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    13bb <simplex_method+0x27b>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    13bb <simplex_method+0x27b>
movl   $0x1,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    13c0 <simplex_method+0x280>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1318 <simplex_method+0x1d8>
cmpl   $0x2,-0x2c(%rbp)
jne    148b <simplex_method+0x34b>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1486 <simplex_method+0x346>
mov    -0x28(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x2,%eax
jne    1473 <simplex_method+0x333>
mov    0x10(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    -0xb0(%rbp),%rax
movslq %edx,%rcx
cmpl   $0x1,(%rax,%rcx,4)
je     1473 <simplex_method+0x333>
mov    -0x10(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1473 <simplex_method+0x333>
movl   $0x1,-0x7c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,-0x6c(%rbp)
movl   $0x1,-0x44(%rbp)
jmp    1478 <simplex_method+0x338>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    13df <simplex_method+0x29f>
jmp    148b <simplex_method+0x34b>
cmpl   $0x0,-0x7c(%rbp)
jne    1530 <simplex_method+0x3f0>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1516 <simplex_method+0x3d6>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14fd <simplex_method+0x3bd>
jp     14fd <simplex_method+0x3bd>
mov    -0x84(%rbp),%eax
mov    %eax,-0x54(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    1290 <simplex_method+0x150>
jmp    1502 <simplex_method+0x3c2>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    14ad <simplex_method+0x36d>
lea    0xafb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x2,-0x4(%rbp)
jmp    1b71 <simplex_method+0xa31>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8c(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    17c3 <simplex_method+0x683>
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    17b0 <simplex_method+0x670>
mov    -0x38(%rbp),%eax
cmp    -0x58(%rbp),%eax
jne    1616 <simplex_method+0x4d6>
mov    -0x90(%rbp),%eax
cmp    -0x54(%rbp),%eax
jne    1616 <simplex_method+0x4d6>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  0xa1c(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1797 <simplex_method+0x657>
mov    -0x38(%rbp),%eax
cmp    -0x58(%rbp),%eax
jne    166b <simplex_method+0x52b>
mov    -0x90(%rbp),%eax
cmp    -0x54(%rbp),%eax
je     166b <simplex_method+0x52b>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1792 <simplex_method+0x652>
mov    -0x90(%rbp),%eax
cmp    -0x54(%rbp),%eax
jne    16d7 <simplex_method+0x597>
mov    -0x38(%rbp),%eax
cmp    -0x58(%rbp),%eax
je     16d7 <simplex_method+0x597>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x68(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    178d <simplex_method+0x64d>
mov    -0x90(%rbp),%eax
cmp    -0x54(%rbp),%eax
je     1788 <simplex_method+0x648>
mov    -0x38(%rbp),%eax
cmp    -0x58(%rbp),%eax
je     1788 <simplex_method+0x648>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
divsd  -0x68(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    178d <simplex_method+0x64d>
jmp    1792 <simplex_method+0x652>
jmp    1797 <simplex_method+0x657>
jmp    179c <simplex_method+0x65c>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    15aa <simplex_method+0x46a>
jmp    17b5 <simplex_method+0x675>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    158f <simplex_method+0x44f>
jmp    17c8 <simplex_method+0x688>
jmp    17cd <simplex_method+0x68d>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    185a <simplex_method+0x71a>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1847 <simplex_method+0x707>
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    17ef <simplex_method+0x6af>
jmp    184c <simplex_method+0x70c>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    17d4 <simplex_method+0x694>
cmpl   $0x1,-0x44(%rbp)
jne    1927 <simplex_method+0x7e7>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    18e6 <simplex_method+0x7a6>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x2,%eax
jne    18d3 <simplex_method+0x793>
mov    0x10(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    -0xb8(%rbp),%rax
movslq %edx,%rcx
cmpl   $0x1,(%rax,%rcx,4)
je     18d3 <simplex_method+0x793>
mov    -0x38(%rbp),%eax
mov    %eax,-0xa0(%rbp)
jmp    18e6 <simplex_method+0x7a6>
jmp    18d8 <simplex_method+0x798>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    186b <simplex_method+0x72b>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1922 <simplex_method+0x7e2>
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    18ed <simplex_method+0x7ad>
jmp    1927 <simplex_method+0x7e7>
lea    0x705(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1a01 <simplex_method+0x8c1>
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x1,%eax
jne    199b <simplex_method+0x85b>
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,%esi
add    $0x1,%esi
lea    0x6ae(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    19e8 <simplex_method+0x8a8>
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x2,%eax
jne    19e3 <simplex_method+0x8a3>
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,%esi
add    $0x1,%esi
lea    0x667(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    19e8 <simplex_method+0x8a8>
jmp    19ed <simplex_method+0x8ad>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    193f <simplex_method+0x7ff>
lea    0x641(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1b6a <simplex_method+0xa2a>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1a88 <simplex_method+0x948>
mov    -0x10(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x5df(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1a37 <simplex_method+0x8f7>
mov    -0xa4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    1aaa <simplex_method+0x96a>
lea    0x5b3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1b51 <simplex_method+0xa11>
mov    -0x28(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
imul   $0x66666667,%rax,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x22,%rax
add    %ecx,%eax
mov    %eax,-0xbc(%rbp)
sub    $0x1,%eax
je     1af5 <simplex_method+0x9b5>
jmp    1ae1 <simplex_method+0x9a1>
mov    -0xbc(%rbp),%eax
sub    $0x2,%eax
je     1b23 <simplex_method+0x9e3>
jmp    1b4c <simplex_method+0xa0c>
mov    -0x28(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,%esi
add    $0x1,%esi
lea    0x53d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1b4c <simplex_method+0xa0c>
mov    -0x28(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,%esi
add    $0x1,%esi
lea    0x514(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1b51 <simplex_method+0xa11>
jmp    1b56 <simplex_method+0xa16>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1a19 <simplex_method+0x8d9>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<simplex_method>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r9d,%r13d
mov    %r8,0x40(%rsp)
mov    %rcx,0x28(%rsp)
mov    %edx,%r14d
mov    %esi,%ebx
mov    %rdi,%r15
lea    0x1(%rbx),%eax
movslq %eax,%r12
lea    0x0(,%r12,8),%rdi
call   1060 <malloc@plt>
mov    %rax,%rbp
mov    %r14,0x10(%rsp)
movslq %r14d,%rax
mov    %rax,0x50(%rsp)
mov    %r12d,%r14d
mov    %rbx,0x20(%rsp)
test   %ebx,%ebx
js     11e6 <simplex_method+0x86>
mov    0x50(%rsp),%rax
lea    0x8(,%rax,8),%r12
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r12,%rdi
call   1060 <malloc@plt>
mov    %rax,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    11d0 <simplex_method+0x70>
cmpl   $0x0,0x10(%rsp)
mov    0x40(%rsp),%r8
mov    0x20(%rsp),%rsi
jle    16f0 <simplex_method+0x590>
mov    0x10(%rsp),%rax
mov    %eax,%r11d
movslq %esi,%rcx
mov    %rcx,0x60(%rsp)
mov    (%r15,%rcx,8),%r12
cmp    $0x1,%eax
jne    1738 <simplex_method+0x5d8>
movsd  0xde0(%rip),%xmm0
xor    %eax,%eax
xor    %edx,%edx
xor    %edi,%edi
test   $0x1,%r11b
je     1253 <simplex_method+0xf3>
movsd  (%r12,%rax,8),%xmm1
ucomisd %xmm1,%xmm0
setbe  %cl
xorpd  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
setb   %bl
or     %cl,%bl
cmovne %edi,%eax
mov    $0x1,%ecx
cmove  %ecx,%edx
mov    %eax,%edi
test   %edx,%edx
je     16f0 <simplex_method+0x590>
mov    %r11,0x58(%rsp)
mov    %r14,0x48(%rsp)
mov    0xa0(%rsp),%r10
test   %esi,%esi
setle  %al
cmp    $0x2,%r13d
setne  %dl
mov    0x10(%rsp),%rcx
lea    0x1(%rcx),%r14d
mov    %esi,%r9d
or     %al,%dl
mov    %dl,0xf(%rsp)
xor    %r11d,%r11d
movsd  0xd72(%rip),%xmm0
xorpd  %xmm1,%xmm1
movsd  0xd6e(%rip),%xmm2
movapd 0xd76(%rip),%xmm3
mov    %r9,%rax
mov    %r9,0x38(%rsp)
mov    %edi,0x1c(%rsp)
movslq %edi,%r13
mov    $0x0,%eax
mov    $0x0,%r12d
test   %esi,%esi
jle    1330 <simplex_method+0x1d0>
xor    %edi,%edi
xor    %r12d,%r12d
movapd %xmm0,%xmm4
xor    %eax,%eax
jmp    12f6 <simplex_method+0x196>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x1,%ecx
cmovne %ecx,%r12d
add    $0x1,%rdi
movapd %xmm5,%xmm4
cmp    %rdi,%r9
je     1330 <simplex_method+0x1d0>
mov    (%r15,%rdi,8),%rbx
mov    0x50(%rsp),%rcx
movsd  (%rbx,%rcx,8),%xmm5
movsd  (%rbx,%r13,8),%xmm6
divsd  %xmm6,%xmm5
ucomisd %xmm5,%xmm4
seta   %bl
ucomisd %xmm1,%xmm6
seta   %cl
mov    %eax,%edx
mov    %edi,%eax
test   %bl,%cl
cmove  %edx,%eax
jne    12e0 <simplex_method+0x180>
movapd %xmm4,%xmm5
jmp    12e0 <simplex_method+0x180>
nopl   (%rax)
cmpb   $0x0,0xf(%rsp)
je     1480 <simplex_method+0x320>
test   %r12d,%r12d
je     14f0 <simplex_method+0x390>
mov    %r11,0x30(%rsp)
movslq %eax,%rdx
mov    (%r15,%rdx,8),%rcx
movsd  (%rcx,%r13,8),%xmm4
mov    (%r8,%rdx,4),%r9d
mov    0x28(%rsp),%rdi
mov    (%rdi,%r13,4),%ebx
mov    %ebx,(%r8,%rdx,4)
mov    %r9d,(%rdi,%r13,4)
test   %esi,%esi
js     17d6 <simplex_method+0x676>
mov    0x1c(%rsp),%r8d
mov    %eax,%edx
xor    %r9d,%r9d
jmp    138f <simplex_method+0x22f>
nop
add    $0x1,%r9
cmp    0x48(%rsp),%r9
je     1450 <simplex_method+0x2f0>
cmpl   $0x0,0x10(%rsp)
js     1380 <simplex_method+0x220>
cmp    %rdx,%r9
setne  %r10b
xor    %r11d,%r11d
cmp    %rdx,%r9
jne    13c0 <simplex_method+0x260>
cmp    %r11,%r8
jne    13c0 <simplex_method+0x260>
mov    (%r15,%r9,8),%rsi
movapd %xmm2,%xmm5
divsd  (%rsi,%r8,8),%xmm5
mov    %r8,%rdi
jmp    1401 <simplex_method+0x2a1>
nopl   (%rax)
cmp    %r11,%r8
sete   %bl
or     %r10b,%bl
je     13f0 <simplex_method+0x290>
cmp    %r11,%r8
jne    1419 <simplex_method+0x2b9>
cmp    %rdx,%r9
je     1419 <simplex_method+0x2b9>
mov    (%r15,%r9,8),%rsi
movsd  (%rsi,%r8,8),%xmm5
xorpd  %xmm3,%xmm5
divsd  %xmm4,%xmm5
mov    %r8,%rdi
jmp    1401 <simplex_method+0x2a1>
nopl   0x0(%rax)
mov    (%r15,%r9,8),%rsi
movsd  (%rsi,%r11,8),%xmm5
divsd  %xmm4,%xmm5
mov    %r11,%rdi
mov    0x0(%rbp,%r9,8),%rsi
movsd  %xmm5,(%rsi,%rdi,8)
add    $0x1,%r11
cmp    %r11,%r14
jne    13a0 <simplex_method+0x240>
jmp    1380 <simplex_method+0x220>
cmp    %r11,%r8
je     140b <simplex_method+0x2ab>
cmp    %rdx,%r9
je     140b <simplex_method+0x2ab>
mov    (%r15,%r9,8),%rsi
movsd  (%rsi,%r13,8),%xmm6
mulsd  (%rcx,%r11,8),%xmm6
movsd  (%rsi,%r11,8),%xmm5
mulsd  %xmm4,%xmm5
subsd  %xmm6,%xmm5
jmp    13fa <simplex_method+0x29a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x40(%rsp),%r8
mov    0x20(%rsp),%rsi
mov    0x38(%rsp),%r9
mov    0xa0(%rsp),%r10
mov    0x30(%rsp),%r11
jmp    1526 <simplex_method+0x3c6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %edi,%edi
jmp    149d <simplex_method+0x33d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rdi
cmp    %rdi,%r9
je     133b <simplex_method+0x1db>
mov    (%r8,%rdi,4),%ebx
lea    -0x14(%rbx),%ecx
cmp    $0x9,%ecx
ja     1490 <simplex_method+0x330>
movzbl %bl,%ecx
imul   $0xcd,%ecx,%edx
shr    $0xa,%edx
and    $0xfffffffe,%edx
lea    (%rdx,%rdx,4),%edx
sub    %dl,%cl
movzbl %cl,%ecx
cmpl   $0x1,(%r10,%rcx,4)
je     1490 <simplex_method+0x330>
mov    (%r15,%rdi,8),%rcx
ucomisd (%rcx,%r13,8),%xmm1
jbe    1490 <simplex_method+0x330>
mov    $0x1,%r11d
mov    %edi,%eax
mov    $0x1,%r12d
jmp    1490 <simplex_method+0x330>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r13
mov    0x60(%rsp),%rax
nopl   0x0(%rax)
cmp    0x50(%rsp),%r13
jge    1722 <simplex_method+0x5c2>
mov    (%r15,%rax,8),%rcx
movsd  (%rcx,%r13,8),%xmm4
addl   $0x1,0x1c(%rsp)
add    $0x1,%r13
ucomisd %xmm1,%xmm4
jne    1500 <simplex_method+0x3a0>
jp     1500 <simplex_method+0x3a0>
test   %r12d,%r12d
mov    0x1c(%rsp),%edi
je     12b2 <simplex_method+0x152>
mov    %r11,0x30(%rsp)
test   %esi,%esi
js     17d6 <simplex_method+0x676>
mov    %r14d,%r8d
and    $0xfffffffc,%r8d
lea    -0x4(%r8),%rbx
mov    %rbx,%r13
shr    $0x2,%r13
add    $0x1,%r13
mov    %r13d,%r11d
and    $0x3,%r11d
and    $0xfffffffffffffffc,%r13
mov    %r14d,%r10d
and    $0x3,%r10d
mov    %r11,%r12
shl    $0x5,%r12
xor    %ecx,%ecx
jmp    158f <simplex_method+0x42f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rcx
cmp    0x48(%rsp),%rcx
je     17d6 <simplex_method+0x676>
cmpl   $0x0,0x10(%rsp)
js     1580 <simplex_method+0x420>
mov    0x0(%rbp,%rcx,8),%rdx
mov    (%r15,%rcx,8),%r9
cmp    $0x4,%r14d
jb     15bb <simplex_method+0x45b>
lea    (%rdx,%r14,8),%rax
cmp    %rax,%r9
jae    1630 <simplex_method+0x4d0>
lea    (%r9,%r14,8),%rax
cmp    %rax,%rdx
jae    1630 <simplex_method+0x4d0>
xor    %eax,%eax
mov    %rax,%rdi
not    %rdi
add    %r14,%rdi
test   %r10,%r10
je     15e5 <simplex_method+0x485>
mov    %r10,%rsi
xchg   %ax,%ax
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    15d0 <simplex_method+0x470>
cmp    $0x3,%rdi
jb     1580 <simplex_method+0x420>
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rax,8)
movsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r9,%rax,8)
movsd  0x10(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x10(%r9,%rax,8)
movsd  0x18(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x18(%r9,%rax,8)
add    $0x4,%rax
cmp    %rax,%r14
jne    15f0 <simplex_method+0x490>
jmp    1580 <simplex_method+0x420>
cmp    $0xc,%rbx
jae    163a <simplex_method+0x4da>
xor    %eax,%eax
jmp    16a4 <simplex_method+0x544>
mov    %r13,%rdi
xor    %eax,%eax
nop
movups (%rdx,%rax,8),%xmm0
movups 0x10(%rdx,%rax,8),%xmm1
movups %xmm0,(%r9,%rax,8)
movups %xmm1,0x10(%r9,%rax,8)
movups 0x20(%rdx,%rax,8),%xmm0
movups 0x30(%rdx,%rax,8),%xmm1
movups %xmm0,0x20(%r9,%rax,8)
movups %xmm1,0x30(%r9,%rax,8)
movups 0x40(%rdx,%rax,8),%xmm0
movups 0x50(%rdx,%rax,8),%xmm1
movups %xmm0,0x40(%r9,%rax,8)
movups %xmm1,0x50(%r9,%rax,8)
movupd 0x60(%rdx,%rax,8),%xmm0
movupd 0x70(%rdx,%rax,8),%xmm1
movupd %xmm0,0x60(%r9,%rax,8)
movupd %xmm1,0x70(%r9,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rdi
jne    1640 <simplex_method+0x4e0>
test   %r11,%r11
je     16df <simplex_method+0x57f>
lea    (%r9,%rax,8),%rdi
add    $0x10,%rdi
lea    (%rdx,%rax,8),%rax
add    $0x10,%rax
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rax,%rsi,1),%xmm0
movupd (%rax,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rdi,%rsi,1)
movupd %xmm1,(%rdi,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r12
jne    16c0 <simplex_method+0x560>
mov    %r8,%rax
cmp    %r14,%r8
je     1580 <simplex_method+0x420>
jmp    15bd <simplex_method+0x45d>
mov    $0x1,%ebp
cmp    $0x2,%r13d
je     17bd <simplex_method+0x65d>
cmp    $0x1,%r13d
jne    19d6 <simplex_method+0x876>
mov    %r15,%rdi
mov    0x10(%rsp),%rdx
mov    0x28(%rsp),%rcx
xor    %eax,%eax
call   1070 <print_result_phase_I@plt>
jmp    19d6 <simplex_method+0x876>
lea    0x92f(%rip),%rdi
call   1030 <puts@plt>
mov    $0x2,%ebp
jmp    19d6 <simplex_method+0x876>
mov    %r11d,%r9d
and    $0xfffffffe,%r9d
movsd  0x8b9(%rip),%xmm0
xor    %eax,%eax
xorpd  %xmm1,%xmm1
mov    $0x1,%r10d
xor    %edx,%edx
xor    %edi,%edi
jmp    1774 <simplex_method+0x614>
nopl   0x0(%rax)
cmove  %ecx,%edi
cmove  %r10d,%edx
add    $0x2,%rax
cmp    %r9,%rax
je     1226 <simplex_method+0xc6>
movsd  (%r12,%rax,8),%xmm2
ucomisd %xmm2,%xmm0
setbe  %bl
ucomisd %xmm2,%xmm1
setb   %cl
or     %bl,%cl
test   %cl,%cl
jne    1792 <simplex_method+0x632>
movapd %xmm2,%xmm0
movsd  0x8(%r12,%rax,8),%xmm2
cmove  %eax,%edi
cmove  %r10d,%edx
ucomisd %xmm2,%xmm0
setbe  %cl
ucomisd %xmm2,%xmm1
setb   %bl
or     %cl,%bl
lea    0x1(%rax),%ecx
test   %bl,%bl
jne    1760 <simplex_method+0x600>
movapd %xmm2,%xmm0
jmp    1760 <simplex_method+0x600>
mov    %r15,%rdi
mov    0x10(%rsp),%rdx
mov    0x28(%rsp),%rcx
xor    %eax,%eax
call   1080 <print_result_phase_II@plt>
jmp    19d6 <simplex_method+0x876>
cmpl   $0x1,0x30(%rsp)
jne    1862 <simplex_method+0x702>
cmpl   $0x0,0x10(%rsp)
jle    1839 <simplex_method+0x6d9>
xor    %eax,%eax
mov    0x20(%rsp),%rsi
mov    0x58(%rsp),%rdi
mov    0xa0(%rsp),%rbp
jmp    1809 <simplex_method+0x6a9>
xchg   %ax,%ax
add    $0x1,%rax
cmp    %rax,%rdi
je     1842 <simplex_method+0x6e2>
mov    0x28(%rsp),%rcx
mov    (%rcx,%rax,4),%ecx
lea    -0x14(%rcx),%edx
cmp    $0x9,%edx
ja     1800 <simplex_method+0x6a0>
movzbl %cl,%ecx
imul   $0xcd,%ecx,%edx
shr    $0xa,%edx
and    $0xfffffffe,%edx
lea    (%rdx,%rdx,4),%edx
sub    %dl,%cl
movzbl %cl,%ecx
cmpl   $0x1,0x0(%rbp,%rcx,4)
je     1800 <simplex_method+0x6a0>
jmp    1844 <simplex_method+0x6e4>
xor    %eax,%eax
mov    0x20(%rsp),%rsi
jmp    1844 <simplex_method+0x6e4>
mov    %edi,%eax
test   %esi,%esi
js     1862 <simplex_method+0x702>
mov    %eax,%eax
mov    (%r15,%rax,8),%rdi
mov    0x38(%rsp),%rax
lea    0x8(,%rax,8),%rdx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x7e2(%rip),%rdi
call   1030 <puts@plt>
cmpl   $0x0,0x10(%rsp)
jle    18db <simplex_method+0x77b>
lea    0x7b4(%rip),%r13
lea    0x7b3(%rip),%r12
xor    %ebp,%ebp
jmp    18bb <simplex_method+0x75b>
nopw   0x0(%rax,%rax,1)
movzbl %al,%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffe,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
add    $0x1,%al
movzbl %al,%esi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,0x58(%rsp)
je     18db <simplex_method+0x77b>
mov    0x28(%rsp),%rax
mov    (%rax,%rbp,4),%eax
lea    -0xa(%rax),%ecx
mov    %r13,%rdi
cmp    $0xa,%ecx
jb     1890 <simplex_method+0x730>
lea    -0x14(%rax),%ecx
mov    %r12,%rdi
cmp    $0x9,%ecx
jbe    1890 <simplex_method+0x730>
jmp    18b0 <simplex_method+0x750>
lea    0x772(%rip),%rdi
call   1030 <puts@plt>
cmpl   $0x0,0x20(%rsp)
js     19d4 <simplex_method+0x874>
lea    0x75d(%rip),%rbx
lea    0x73c(%rip),%r12
xor    %ebp,%ebp
jmp    1927 <simplex_method+0x7c7>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbx,%rdi
call   1030 <puts@plt>
add    $0x1,%rbp
cmp    0x48(%rsp),%rbp
je     19d4 <simplex_method+0x874>
cmpl   $0x0,0x10(%rsp)
js     195d <simplex_method+0x7fd>
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rbp,8),%rax
movsd  (%rax,%r13,8),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x1,%r13
cmp    %r13,%r14
jne    1940 <simplex_method+0x7e0>
cmp    0x38(%rsp),%rbp
je     1910 <simplex_method+0x7b0>
mov    0x40(%rsp),%rax
movslq (%rax,%rbp,4),%rsi
imul   $0x66666667,%rsi,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x22,%rax
add    %ecx,%eax
cmp    $0x2,%eax
je     19b7 <simplex_method+0x857>
cmp    $0x1,%eax
jne    1918 <simplex_method+0x7b8>
movslq %esi,%rax
imul   $0x66666667,%rax,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x22,%rax
add    %ecx,%eax
add    %eax,%eax
lea    (%rax,%rax,4),%eax
neg    %eax
add    %eax,%esi
add    $0x1,%esi
lea    0x68c(%rip),%rdi
jmp    19c8 <simplex_method+0x868>
add    %eax,%eax
lea    (%rax,%rax,4),%eax
sub    %eax,%esi
add    $0x1,%esi
lea    0x67e(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    1918 <simplex_method+0x7b8>
xor    %ebp,%ebp
mov    %ebp,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str.2 = [6 x i8] c"X%d\09\09\00"
@.str.3 = [6 x i8] c"Z%d\09\09\00"
@.str.5 = [5 x i8] c"%lf\09\00"
@.str.7 = [5 x i8] c"X%d\0A\00"
@.str.8 = [5 x i8] c"Z%d\0A\00"
@str = [9 x i8] c"\0ATable: \00"
@str.9 = [2 x i8] c"1\00"
@str.10 = [2 x i8] c"Z\00"
@str.11 = [26 x i8] c"The solution is unbounded\00"
define i32 @simplex_method(double** %0, i32 %1, i32 %2, i32* %3, i32* %4, i32 %5, i32* nocapture %6) {
%8 = add i32 %1, 1
%9 = sext i32 %8 to i64
%10 = shl nsw i64 %9, 3
%11 = tail call i8* @malloc(i64 %10)
%12 = bitcast i8* %11 to double**
%13 = icmp slt i32 %1, 0
br i1 %13, label %19, label %14
14: ; preds = %7
%15 = add nsw i32 %2, 1
%16 = sext i32 %15 to i64
%17 = shl nsw i64 %16, 3
%18 = zext i32 %8 to i64
br label %30
19: ; preds = %30, %7
%20 = icmp sgt i32 %2, 0
br i1 %20, label %21, label %104
21: ; preds = %19
%22 = sext i32 %1 to i64
%23 = getelementptr inbounds double*, double** %0, i64 %22
%24 = load double*, double** %23
%25 = zext i32 %2 to i64
%26 = and i64 %25, 1
%27 = icmp eq i32 %2, 1
br i1 %27, label %37, label %28
28: ; preds = %21
%29 = and i64 %25, 4294967294
br label %71
30: ; preds = %14, %30
%31 = phi i64 [ 0, %14 ], [ %35, %30 ]
%32 = tail call i8* @malloc(i64 %17)
%33 = getelementptr inbounds double*, double** %12, i64 %31
%34 = bitcast double** %33 to i8**
store i8* %32, i8** %34
%35 = add nuw nsw i64 %31, 1
%36 = icmp eq i64 %35, %18
br i1 %36, label %19, label %30
37: ; preds = %71, %21
%38 = phi i32 [ undef, %21 ], [ %93, %71 ]
%39 = phi i32 [ undef, %21 ], [ %95, %71 ]
%40 = phi i64 [ 0, %21 ], [ %96, %71 ]
%41 = phi i32 [ 0, %21 ], [ %95, %71 ]
%42 = phi i32 [ 0, %21 ], [ %93, %71 ]
%43 = phi double [ 1.000000e+02, %21 ], [ %91, %71 ]
%44 = icmp eq i64 %26, 0
br i1 %44, label %54, label %45
45: ; preds = %37
%46 = getelementptr inbounds double, double* %24, i64 %40
%47 = load double, double* %46
%48 = fcmp uge double %47, %43
%49 = fcmp ugt double %47, 0.000000e+00
%50 = or i1 %48, %49
%51 = trunc i64 %40 to i32
%52 = select i1 %50, i32 %42, i32 %51
%53 = select i1 %50, i32 %41, i32 1
br label %54
54: ; preds = %37, %45
%55 = phi i32 [ %38, %37 ], [ %52, %45 ]
%56 = phi i32 [ %39, %37 ], [ %53, %45 ]
%57 = icmp eq i32 %56, 0
%58 = icmp sgt i32 %1, 0
%59 = sext i32 %2 to i64
%60 = icmp slt i32 %2, 0
%61 = getelementptr inbounds double*, double** %0, i64 %22
br i1 %57, label %104, label %62
62: ; preds = %54
%63 = icmp slt i32 %1, 1
%64 = icmp ne i32 %5, 2
%65 = add i32 %2, 1
%66 = zext i32 %1 to i64
%67 = or i1 %64, %63
%68 = zext i32 %1 to i64
%69 = zext i32 %8 to i64
%70 = zext i32 %65 to i64
br label %99
71: ; preds = %71, %28
%72 = phi i64 [ 0, %28 ], [ %96, %71 ]
%73 = phi i32 [ 0, %28 ], [ %95, %71 ]
%74 = phi i32 [ 0, %28 ], [ %93, %71 ]
%75 = phi double [ 1.000000e+02, %28 ], [ %91, %71 ]
%76 = phi i64 [ 0, %28 ], [ %97, %71 ]
%77 = getelementptr inbounds double, double* %24, i64 %72
%78 = load double, double* %77
%79 = fcmp uge double %78, %75
%80 = fcmp ugt double %78, 0.000000e+00
%81 = or i1 %79, %80
%82 = select i1 %81, double %75, double %78
%83 = trunc i64 %72 to i32
%84 = select i1 %81, i32 %74, i32 %83
%85 = or i64 %72, 1
%86 = getelementptr inbounds double, double* %24, i64 %85
%87 = load double, double* %86
%88 = fcmp uge double %87, %82
%89 = fcmp ugt double %87, 0.000000e+00
%90 = or i1 %88, %89
%91 = select i1 %90, double %82, double %87
%92 = trunc i64 %85 to i32
%93 = select i1 %90, i32 %84, i32 %92
%94 = select i1 %90, i1 %81, i1 false
%95 = select i1 %94, i32 %73, i32 1
%96 = add nuw nsw i64 %72, 2
%97 = add i64 %76, 2
%98 = icmp eq i64 %97, %29
br i1 %98, label %37, label %71
99: ; preds = %62, %256
%100 = phi i32 [ %166, %256 ], [ 0, %62 ]
%101 = phi i32 [ %257, %256 ], [ %55, %62 ]
br i1 %58, label %102, label %130
102: ; preds = %99
%103 = sext i32 %101 to i64
br label %109
104: ; preds = %19, %54
switch i32 %5, label %488 [
i32 1, label %105
i32 2, label %107
]
105: ; preds = %104
%106 = tail call i32 (double**, i32, i32, i32*, i32*, ...) bitcast (i32 (...)* @print_result_phase_I to i32 (double**, i32, i32, i32*, i32*, ...)*)(double** %0, i32 %1, i32 %2, i32* %3, i32* %4)
br label %488
107: ; preds = %104
%108 = tail call i32 (double**, i32, i32, i32*, i32*, ...) bitcast (i32 (...)* @print_result_phase_II to i32 (double**, i32, i32, i32*, i32*, ...)*)(double** %0, i32 %1, i32 %2, i32* %3, i32* %4)
br label %488
109: ; preds = %102, %109
%110 = phi i64 [ 0, %102 ], [ %128, %109 ]
%111 = phi i32 [ 0, %102 ], [ %127, %109 ]
%112 = phi double [ 1.000000e+04, %102 ], [ %126, %109 ]
%113 = phi i32 [ 0, %102 ], [ %125, %109 ]
%114 = getelementptr inbounds double*, double** %0, i64 %110
%115 = load double*, double** %114
%116 = getelementptr inbounds double, double* %115, i64 %59
%117 = load double, double* %116
%118 = getelementptr inbounds double, double* %115, i64 %103
%119 = load double, double* %118
%120 = fdiv double %117, %119
%121 = fcmp olt double %120, %112
%122 = fcmp ogt double %119, 0.000000e+00
%123 = and i1 %122, %121
%124 = trunc i64 %110 to i32
%125 = select i1 %123, i32 %124, i32 %113
%126 = select i1 %123, double %120, double %112
%127 = select i1 %123, i32 1, i32 %111
%128 = add nuw nsw i64 %110, 1
%129 = icmp eq i64 %128, %66
br i1 %129, label %130, label %109
130: ; preds = %109, %99
%131 = phi i32 [ 0, %99 ], [ %125, %109 ]
%132 = phi i32 [ 0, %99 ], [ %127, %109 ]
br i1 %67, label %165, label %133
133: ; preds = %130
%134 = sext i32 %101 to i64
br label %135
135: ; preds = %133, %159
%136 = phi i64 [ 0, %133 ], [ %163, %159 ]
%137 = phi i32 [ %132, %133 ], [ %162, %159 ]
%138 = phi i32 [ %131, %133 ], [ %161, %159 ]
%139 = phi i32 [ %100, %133 ], [ %160, %159 ]
%140 = getelementptr inbounds i32, i32* %4, i64 %136
%141 = load i32, i32* %140
%142 = add i32 %141, -20
%143 = icmp ult i32 %142, 10
br i1 %143, label %144, label %159
144: ; preds = %135
%145 = trunc i32 %141 to i8
%146 = urem i8 %145, 10
%147 = zext i8 %146 to i64
%148 = getelementptr inbounds i32, i32* %6, i64 %147
%149 = load i32, i32* %148
%150 = icmp eq i32 %149, 1
br i1 %150, label %159, label %151
151: ; preds = %144
%152 = getelementptr inbounds double*, double** %0, i64 %136
%153 = load double*, double** %152
%154 = getelementptr inbounds double, double* %153, i64 %134
%155 = load double, double* %154
%156 = fcmp olt double %155, 0.000000e+00
br i1 %156, label %157, label %159
157: ; preds = %151
%158 = trunc i64 %136 to i32
br label %159
159: ; preds = %135, %144, %151, %157
%160 = phi i32 [ 1, %157 ], [ %139, %151 ], [ %139, %144 ], [ %139, %135 ]
%161 = phi i32 [ %158, %157 ], [ %138, %151 ], [ %138, %144 ], [ %138, %135 ]
%162 = phi i32 [ 1, %157 ], [ %137, %151 ], [ %137, %144 ], [ %137, %135 ]
%163 = add nuw nsw i64 %136, 1
%164 = icmp eq i64 %163, %68
br i1 %164, label %165, label %135
165: ; preds = %159, %130
%166 = phi i32 [ %100, %130 ], [ %160, %159 ]
%167 = phi i32 [ %131, %130 ], [ %161, %159 ]
%168 = phi i32 [ %132, %130 ], [ %162, %159 ]
%169 = icmp eq i32 %168, 0
br i1 %169, label %170, label %183
170: ; preds = %165
%171 = sext i32 %101 to i64
br label %172
172: ; preds = %170, %176
%173 = phi i64 [ %171, %170 ], [ %174, %176 ]
%174 = add nsw i64 %173, 1
%175 = icmp slt i64 %174, %59
br i1 %175, label %176, label %181
176: ; preds = %172
%177 = load double*, double** %61
%178 = getelementptr inbounds double, double* %177, i64 %174
%179 = load double, double* %178
%180 = fcmp oeq double %179, 0.000000e+00
br i1 %180, label %254, label %172
181: ; preds = %172
%182 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.11, i64 0, i64 0))
br label %488
183: ; preds = %165
%184 = sext i32 %167 to i64
%185 = getelementptr inbounds double*, double** %0, i64 %184
%186 = load double*, double** %185
%187 = sext i32 %101 to i64
%188 = getelementptr inbounds double, double* %186, i64 %187
%189 = load double, double* %188
%190 = getelementptr inbounds i32, i32* %4, i64 %184
%191 = load i32, i32* %190
%192 = getelementptr inbounds i32, i32* %3, i64 %187
%193 = load i32, i32* %192
store i32 %193, i32* %190
store i32 %191, i32* %192
br i1 %13, label %395, label %194
194: ; preds = %183
%195 = zext i32 %101 to i64
%196 = zext i32 %167 to i64
br label %197
197: ; preds = %194, %251
%198 = phi i64 [ 0, %194 ], [ %252, %251 ]
br i1 %60, label %251, label %199
199: ; preds = %197
%200 = icmp eq i64 %198, %196
%201 = xor i1 %200, true
%202 = getelementptr inbounds double*, double** %0, i64 %198
%203 = getelementptr inbounds double*, double** %12, i64 %198
br label %204
204: ; preds = %199, %248
%205 = phi i64 [ 0, %199 ], [ %249, %248 ]
%206 = icmp eq i64 %205, %195
%207 = select i1 %200, i1 %206, i1 false
br i1 %207, label %208, label %213
208: ; preds = %204
%209 = load double*, double** %202
%210 = getelementptr inbounds double, double* %209, i64 %195
%211 = load double, double* %210
%212 = fdiv double 1.000000e+00, %211
br label %243
213: ; preds = %204
%214 = select i1 %201, i1 true, i1 %206
br i1 %214, label %220, label %215
215: ; preds = %213
%216 = load double*, double** %202
%217 = getelementptr inbounds double, double* %216, i64 %205
%218 = load double, double* %217
%219 = fdiv double %218, %189
br label %243
220: ; preds = %213
%221 = icmp ne i64 %205, %195
%222 = select i1 %221, i1 true, i1 %200
br i1 %222, label %229, label %223
223: ; preds = %220
%224 = load double*, double** %202
%225 = getelementptr inbounds double, double* %224, i64 %195
%226 = load double, double* %225
%227 = fneg double %226
%228 = fdiv double %227, %189
br label %243
229: ; preds = %220
%230 = select i1 %206, i1 true, i1 %200
br i1 %230, label %248, label %231
231: ; preds = %229
%232 = load double*, double** %202
%233 = getelementptr inbounds double, double* %232, i64 %205
%234 = load double, double* %233
%235 = getelementptr inbounds double, double* %186, i64 %205
%236 = load double, double* %235
%237 = getelementptr inbounds double, double* %232, i64 %187
%238 = load double, double* %237
%239 = fneg double %236
%240 = fmul double %238, %239
%241 = tail call double @llvm.fmuladd.f64(double %234, double %189, double %240)
%242 = fdiv double %241, %189
br label %243
243: ; preds = %215, %231, %223, %208
%244 = phi i64 [ %195, %208 ], [ %195, %223 ], [ %205, %231 ], [ %205, %215 ]
%245 = phi double [ %212, %208 ], [ %228, %223 ], [ %242, %231 ], [ %219, %215 ]
%246 = load double*, double** %203
%247 = getelementptr inbounds double, double* %246, i64 %244
store double %245, double* %247
br label %248
248: ; preds = %243, %229
%249 = add nuw nsw i64 %205, 1
%250 = icmp eq i64 %249, %70
br i1 %250, label %251, label %204
251: ; preds = %248, %197
%252 = add nuw nsw i64 %198, 1
%253 = icmp eq i64 %252, %69
br i1 %253, label %256, label %197
254: ; preds = %176
%255 = trunc i64 %174 to i32
br label %256
256: ; preds = %251, %254
%257 = phi i32 [ %255, %254 ], [ %101, %251 ]
br i1 %169, label %99, label %258
258: ; preds = %256
br i1 %13, label %395, label %259
259: ; preds = %258
%260 = zext i32 %8 to i64
%261 = zext i32 %65 to i64
%262 = and i64 %70, 4294967292
%263 = add nsw i64 %262, -4
%264 = lshr exact i64 %263, 2
%265 = add nuw nsw i64 %264, 1
%266 = icmp ult i32 %65, 4
%267 = and i64 %70, 4294967292
%268 = and i64 %265, 3
%269 = icmp ult i64 %263, 12
%270 = and i64 %265, 9223372036854775804
%271 = icmp eq i64 %268, 0
%272 = icmp eq i64 %267, %70
%273 = and i64 %70, 3
%274 = icmp eq i64 %273, 0
br label %275
275: ; preds = %259, %392
%276 = phi i64 [ 0, %259 ], [ %393, %392 ]
br i1 %60, label %392, label %277
277: ; preds = %275
%278 = getelementptr inbounds double*, double** %12, i64 %276
%279 = load double*, double** %278
%280 = getelementptr inbounds double*, double** %0, i64 %276
%281 = load double*, double** %280
br i1 %266, label %357, label %282
282: ; preds = %277
%283 = getelementptr double, double* %281, i64 %70
%284 = getelementptr double, double* %279, i64 %70
%285 = icmp ult double* %281, %284
%286 = icmp ult double* %279, %283
%287 = and i1 %285, %286
br i1 %287, label %357, label %288
288: ; preds = %282
br i1 %269, label %338, label %289
289: ; preds = %288, %289
%290 = phi i64 [ %335, %289 ], [ 0, %288 ]
%291 = phi i64 [ %336, %289 ], [ 0, %288 ]
%292 = getelementptr inbounds double, double* %279, i64 %290
%293 = bitcast double* %292 to <2 x double>*
%294 = load <2 x double>, <2 x double>* %293
%295 = getelementptr inbounds double, double* %292, i64 2
%296 = bitcast double* %295 to <2 x double>*
%297 = load <2 x double>, <2 x double>* %296
%298 = getelementptr inbounds double, double* %281, i64 %290
%299 = bitcast double* %298 to <2 x double>*
store <2 x double> %294, <2 x double>* %299
%300 = getelementptr inbounds double, double* %298, i64 2
%301 = bitcast double* %300 to <2 x double>*
store <2 x double> %297, <2 x double>* %301
%302 = or i64 %290, 4
%303 = getelementptr inbounds double, double* %279, i64 %302
%304 = bitcast double* %303 to <2 x double>*
%305 = load <2 x double>, <2 x double>* %304
%306 = getelementptr inbounds double, double* %303, i64 2
%307 = bitcast double* %306 to <2 x double>*
%308 = load <2 x double>, <2 x double>* %307
%309 = getelementptr inbounds double, double* %281, i64 %302
%310 = bitcast double* %309 to <2 x double>*
store <2 x double> %305, <2 x double>* %310
%311 = getelementptr inbounds double, double* %309, i64 2
%312 = bitcast double* %311 to <2 x double>*
store <2 x double> %308, <2 x double>* %312
%313 = or i64 %290, 8
%314 = getelementptr inbounds double, double* %279, i64 %313
%315 = bitcast double* %314 to <2 x double>*
%316 = load <2 x double>, <2 x double>* %315
%317 = getelementptr inbounds double, double* %314, i64 2
%318 = bitcast double* %317 to <2 x double>*
%319 = load <2 x double>, <2 x double>* %318
%320 = getelementptr inbounds double, double* %281, i64 %313
%321 = bitcast double* %320 to <2 x double>*
store <2 x double> %316, <2 x double>* %321
%322 = getelementptr inbounds double, double* %320, i64 2
%323 = bitcast double* %322 to <2 x double>*
store <2 x double> %319, <2 x double>* %323
%324 = or i64 %290, 12
%325 = getelementptr inbounds double, double* %279, i64 %324
%326 = bitcast double* %325 to <2 x double>*
%327 = load <2 x double>, <2 x double>* %326
%328 = getelementptr inbounds double, double* %325, i64 2
%329 = bitcast double* %328 to <2 x double>*
%330 = load <2 x double>, <2 x double>* %329
%331 = getelementptr inbounds double, double* %281, i64 %324
%332 = bitcast double* %331 to <2 x double>*
store <2 x double> %327, <2 x double>* %332
%333 = getelementptr inbounds double, double* %331, i64 2
%334 = bitcast double* %333 to <2 x double>*
store <2 x double> %330, <2 x double>* %334
%335 = add nuw i64 %290, 16
%336 = add nuw i64 %291, 4
%337 = icmp eq i64 %336, %270
br i1 %337, label %338, label %289
338: ; preds = %289, %288
%339 = phi i64 [ 0, %288 ], [ %335, %289 ]
br i1 %271, label %356, label %340
340: ; preds = %338, %340
%341 = phi i64 [ %353, %340 ], [ %339, %338 ]
%342 = phi i64 [ %354, %340 ], [ 0, %338 ]
%343 = getelementptr inbounds double, double* %279, i64 %341
%344 = bitcast double* %343 to <2 x double>*
%345 = load <2 x double>, <2 x double>* %344
%346 = getelementptr inbounds double, double* %343, i64 2
%347 = bitcast double* %346 to <2 x double>*
%348 = load <2 x double>, <2 x double>* %347
%349 = getelementptr inbounds double, double* %281, i64 %341
%350 = bitcast double* %349 to <2 x double>*
store <2 x double> %345, <2 x double>* %350
%351 = getelementptr inbounds double, double* %349, i64 2
%352 = bitcast double* %351 to <2 x double>*
store <2 x double> %348, <2 x double>* %352
%353 = add nuw i64 %341, 4
%354 = add i64 %342, 1
%355 = icmp eq i64 %354, %268
br i1 %355, label %356, label %340
356: ; preds = %340, %338
br i1 %272, label %392, label %357
357: ; preds = %282, %277, %356
%358 = phi i64 [ 0, %282 ], [ 0, %277 ], [ %267, %356 ]
%359 = xor i64 %358, -1
%360 = add nsw i64 %359, %70
br i1 %274, label %370, label %361
361: ; preds = %357, %361
%362 = phi i64 [ %367, %361 ], [ %358, %357 ]
%363 = phi i64 [ %368, %361 ], [ 0, %357 ]
%364 = getelementptr inbounds double, double* %279, i64 %362
%365 = load double, double* %364
%366 = getelementptr inbounds double, double* %281, i64 %362
store double %365, double* %366
%367 = add nuw nsw i64 %362, 1
%368 = add i64 %363, 1
%369 = icmp eq i64 %368, %273
br i1 %369, label %370, label %361
370: ; preds = %361, %357
%371 = phi i64 [ %358, %357 ], [ %367, %361 ]
%372 = icmp ult i64 %360, 3
br i1 %372, label %392, label %373
373: ; preds = %370, %373
%374 = phi i64 [ %390, %373 ], [ %371, %370 ]
%375 = getelementptr inbounds double, double* %279, i64 %374
%376 = load double, double* %375
%377 = getelementptr inbounds double, double* %281, i64 %374
store double %376, double* %377
%378 = add nuw nsw i64 %374, 1
%379 = getelementptr inbounds double, double* %279, i64 %378
%380 = load double, double* %379
%381 = getelementptr inbounds double, double* %281, i64 %378
store double %380, double* %381
%382 = add nuw nsw i64 %374, 2
%383 = getelementptr inbounds double, double* %279, i64 %382
%384 = load double, double* %383
%385 = getelementptr inbounds double, double* %281, i64 %382
store double %384, double* %385
%386 = add nuw nsw i64 %374, 3
%387 = getelementptr inbounds double, double* %279, i64 %386
%388 = load double, double* %387
%389 = getelementptr inbounds double, double* %281, i64 %386
store double %388, double* %389
%390 = add nuw nsw i64 %374, 4
%391 = icmp eq i64 %390, %261
br i1 %391, label %392, label %373
392: ; preds = %370, %373, %356, %275
%393 = add nuw nsw i64 %276, 1
%394 = icmp eq i64 %393, %260
br i1 %394, label %395, label %275
395: ; preds = %183, %392, %258
%396 = icmp eq i32 %166, 1
br i1 %396, label %397, label %428
397: ; preds = %395
br i1 %20, label %398, label %418
398: ; preds = %397
%399 = zext i32 %2 to i64
br label %400
400: ; preds = %398, %413
%401 = phi i64 [ 0, %398 ], [ %414, %413 ]
%402 = getelementptr inbounds i32, i32* %3, i64 %401
%403 = load i32, i32* %402
%404 = add i32 %403, -20
%405 = icmp ult i32 %404, 10
br i1 %405, label %406, label %413
406: ; preds = %400
%407 = trunc i32 %403 to i8
%408 = urem i8 %407, 10
%409 = zext i8 %408 to i64
%410 = getelementptr inbounds i32, i32* %6, i64 %409
%411 = load i32, i32* %410
%412 = icmp eq i32 %411, 1
br i1 %412, label %413, label %416
413: ; preds = %400, %406
%414 = add nuw nsw i64 %401, 1
%415 = icmp eq i64 %414, %399
br i1 %415, label %418, label %400
416: ; preds = %406
%417 = trunc i64 %401 to i32
br label %418
418: ; preds = %413, %416, %397
%419 = phi i32 [ 0, %397 ], [ %417, %416 ], [ %2, %413 ]
br i1 %13, label %428, label %420
420: ; preds = %418
%421 = zext i32 %419 to i64
%422 = getelementptr inbounds double*, double** %0, i64 %421
%423 = bitcast double** %422 to i8**
%424 = load i8*, i8** %423
%425 = zext i32 %1 to i64
%426 = shl nuw nsw i64 %425, 3
%427 = add nuw nsw i64 %426, 8
br label %428
428: ; preds = %420, %418, %395
%429 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @str, i64 0, i64 0))
br i1 %20, label %430, label %451
430: ; preds = %428
%431 = zext i32 %2 to i64
br label %432
432: ; preds = %430, %448
%433 = phi i64 [ 0, %430 ], [ %449, %448 ]
%434 = getelementptr inbounds i32, i32* %3, i64 %433
%435 = load i32, i32* %434
%436 = add i32 %435, -10
%437 = icmp ult i32 %436, 10
br i1 %437, label %441, label %438
438: ; preds = %432
%439 = add i32 %435, -20
%440 = icmp ult i32 %439, 10
br i1 %440, label %441, label %448
441: ; preds = %438, %432
%442 = phi i8* [ getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), %432 ], [ getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), %438 ]
%443 = trunc i32 %435 to i8
%444 = urem i8 %443, 10
%445 = add nuw nsw i8 %444, 1
%446 = zext i8 %445 to i32
%447 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) %442, i32 %446)
br label %448
448: ; preds = %441, %438
%449 = add nuw nsw i64 %433, 1
%450 = icmp eq i64 %449, %431
br i1 %450, label %451, label %432
451: ; preds = %448, %428
%452 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.9, i64 0, i64 0))
br i1 %13, label %488, label %453
453: ; preds = %451
%454 = zext i32 %1 to i64
%455 = zext i32 %8 to i64
%456 = zext i32 %65 to i64
br label %457
457: ; preds = %453, %485
%458 = phi i64 [ 0, %453 ], [ %486, %485 ]
br i1 %60, label %469, label %459
459: ; preds = %457
%460 = getelementptr inbounds double*, double** %0, i64 %458
br label %461
461: ; preds = %459, %461
%462 = phi i64 [ 0, %459 ], [ %467, %461 ]
%463 = load double*, double** %460
%464 = getelementptr inbounds double, double* %463, i64 %462
%465 = load double, double* %464
%466 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), double %465)
%467 = add nuw nsw i64 %462, 1
%468 = icmp eq i64 %467, %456
br i1 %468, label %469, label %461
469: ; preds = %461, %457
%470 = icmp eq i64 %458, %454
br i1 %470, label %471, label %473
471: ; preds = %469
%472 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.10, i64 0, i64 0))
br label %485
473: ; preds = %469
%474 = getelementptr inbounds i32, i32* %4, i64 %458
%475 = load i32, i32* %474
%476 = sdiv i32 %475, 10
%477 = srem i32 %475, 10
switch i32 %476, label %485 [
i32 1, label %478
i32 2, label %482
]
478: ; preds = %473
%479 = srem i32 %475, 10
%480 = add nsw i32 %479, 1
%481 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0), i32 %480)
br label %485
482: ; preds = %473
%483 = add nsw i32 %477, 1
%484 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.8, i64 0, i64 0), i32 %483)
br label %485
485: ; preds = %471, %473, %482, %478
%486 = add nuw nsw i64 %458, 1
%487 = icmp eq i64 %486, %455
br i1 %487, label %488, label %457
488: ; preds = %485, %451, %181, %105, %107, %104
%489 = phi i32 [ 1, %104 ], [ 1, %107 ], [ 1, %105 ], [ 2, %181 ], [ 0, %451 ], [ 0, %485 ]
ret i32 %489
}