#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 */
struct stat {
  int /*<<< orphan*/ st_mode;
};
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ S_ISDIR(int /*<<< orphan*/);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
scalar_t__ malloc(int);
int /*<<< orphan*/ mkdir(char const *, int);
int /*<<< orphan*/ printf(char *, ...);
scalar_t__ stat(char const *, struct stat *);
void create_model(int FWTR, int *nNode, double *dim_x, double *dim_y,
                  double **node2xy, int *nElem, int **elem2node, int **elem2loc,
                  int *nDOF, int **node2DOF, int **DOFx, int **DOFy,
                  int *nDOFsrf, int **DOFx_srf, int **DOFy_srf, double *h) {
  int i0, i1, i2;
  int nNodeX, nNodeY;
  int nElemX, nElemY;
  int elem, node;
  FILE *fid;
  const char *folderr;
  struct stat sb;
  printf("----- creating model -----\n");
  *dim_x = 40.;
  *dim_y = 40.;
  *h = .1;
  nNodeX = (int)((*dim_x) / (*h) + 1e-3) + 1;
  nNodeY = (int)((*dim_y) / (*h) + 1e-3) + 1;
  *nNode = nNodeX * nNodeY;
  (*node2xy) = (double *)malloc((*nNode) * 2 * sizeof(double));
  for (i0 = 0; i0 < nNodeX; i0++) {
    for (i1 = 0; i1 < nNodeY; i1++) {
      node = i0 * nNodeY + i1;
      (*node2xy)[2 * node] = i0 * (*h);
      (*node2xy)[2 * node + 1] = i1 * (*h);
    }
  }
  nElemX = (nNodeX - 1) / 2;
  nElemY = (nNodeY - 1) / 2;
  *nElem = nElemX * nElemY;
  (*elem2node) = (int *)malloc((*nElem) * 9 * sizeof(int));
  for (i0 = 0; i0 < nElemX; i0++) {
    for (i1 = 0; i1 < nElemY; i1++) {
      elem = i0 * nElemY + i1;
      (*elem2node)[9 * elem] = (2 * i0) * nNodeY + (2 * i1);
      (*elem2node)[9 * elem + 1] = (2 * i0 + 2) * nNodeY + (2 * i1);
      (*elem2node)[9 * elem + 2] = (2 * i0 + 2) * nNodeY + (2 * i1 + 2);
      (*elem2node)[9 * elem + 3] = (2 * i0) * nNodeY + (2 * i1 + 2);
    }
  }
  for (i0 = 0; i0 < *nElem; i0++) {
    (*elem2node)[9 * i0 + 4] =
        ((*elem2node)[9 * i0] + (*elem2node)[9 * i0 + 1]) / 2;
    (*elem2node)[9 * i0 + 5] = (*elem2node)[9 * i0 + 1] + 1;
    (*elem2node)[9 * i0 + 6] =
        ((*elem2node)[9 * i0 + 2] + (*elem2node)[9 * i0 + 3]) / 2;
    (*elem2node)[9 * i0 + 7] = (*elem2node)[9 * i0 + 3] - 1;
    (*elem2node)[9 * i0 + 8] =
        ((*elem2node)[9 * i0] + (*elem2node)[9 * i0 + 1]) / 2 + 1;
  }
  (*node2DOF) = (int *)malloc((*nNode) * 2 * sizeof(int));
  for (i0 = 0; i0 < (*nNode) * 2; i0++) {
    (*node2DOF)[i0] = -1;
  }
  (*nDOF) = 0;
  (*nDOFsrf) = 0;
  for (i0 = 0; i0 < (*nNode); i0++) {
    if ((*node2xy)[2 * i0] > .001 && (*node2xy)[2 * i0] < (*dim_x) - .001 &&
        (*node2xy)[2 * i0 + 1] > (*dim_y) - .001) {
      (*node2DOF)[2 * i0] = (*nDOF)++;
      (*nDOFsrf)++;
      (*node2DOF)[2 * i0 + 1] = (*nDOF)++;
      (*nDOFsrf)++;
    }
  }
  for (i0 = 0; i0 < (*nNode); i0++) {
    if ((*node2xy)[2 * i0] > .001 && (*node2xy)[2 * i0] < (*dim_x) - .001 &&
        (*node2xy)[2 * i0 + 1] > .001) {
      if ((*node2DOF)[2 * i0] == -1)
        (*node2DOF)[2 * i0] = (*nDOF)++;
      if ((*node2DOF)[2 * i0 + 1] == -1)
        (*node2DOF)[2 * i0 + 1] = (*nDOF)++;
    }
  }
  if (FWTR == 1) {
    printf(" adjusting DOF...\n");
    for (i0 = 0; i0 < (*nNode); i0++) {
      for (i1 = 0; i1 < 2; i1++) {
        if ((*node2DOF)[2 * i0 + i1] < (*nDOFsrf) &&
            (*node2DOF)[2 * i0 + i1] > -1)
          (*node2DOF)[2 * i0 + i1] = -(*node2DOF)[2 * i0 + i1] - 2;
        else if ((*node2DOF)[2 * i0 + i1] > (*nDOFsrf) - 1)
          (*node2DOF)[2 * i0 + i1] -= (*nDOFsrf);
      }
    }
    (*nDOF) -= (*nDOFsrf);
  }
  (*DOFx) = (int *)malloc((*nDOF) / 2 * sizeof(int));
  (*DOFy) = (int *)malloc((*nDOF) / 2 * sizeof(int));
  i1 = 0;
  folderr = "./output/";
  if (stat(folderr, &sb) != 0 || !S_ISDIR(sb.st_mode)) {
    printf("Output foler does not exist. Creating.\n");
    mkdir(folderr, 0777);
  }
  fid = fopen("output/node2xy.txt", "wt");
  for (i0 = 0; i0 < (*nNode); i0++) {
    if ((*node2DOF)[2 * i0] > -1) {
      (*DOFx)[i1] = (*node2DOF)[2 * i0];
      (*DOFy)[i1++] = (*node2DOF)[2 * i0 + 1];
      fprintf(fid, "%e %e\n", (*node2xy)[2 * i0], (*node2xy)[2 * i0 + 1]);
    }
  }
  fclose(fid);
  printf("  dim x=%f, dim y=%f\n", (*dim_x), (*dim_y));
  printf("   nDOF=%i\n", (*nDOF));
  printf("  nNode=%i\n", (*nNode));
  printf("  nElem=%i\n", (*nElem));
  printf("nDOFsrf=%i\n", (*nDOFsrf));
  (*DOFx_srf) = (int *)malloc((*nDOFsrf) / 2 * sizeof(int));
  (*DOFy_srf) = (int *)malloc((*nDOFsrf) / 2 * sizeof(int));
  i1 = 0;
  if (FWTR == 0) {
    for (i0 = 0; i0 < (*nNode); i0++) {
      if ((*node2xy)[2 * i0] > .001 && (*node2xy)[2 * i0] < (*dim_x) - .001 &&
          (*node2xy)[2 * i0 + 1] > (*dim_y) - .001) {
        (*DOFx_srf)[i1] = (*node2DOF)[2 * i0];
        (*DOFy_srf)[i1++] = (*node2DOF)[2 * i0 + 1];
      }
    }
  } else if (FWTR == 1) {
    for (i0 = 0; i0 < (*nNode); i0++) {
      if ((*node2xy)[2 * i0] > .001 && (*node2xy)[2 * i0] < (*dim_x) - .001 &&
          (*node2xy)[2 * i0 + 1] > (*dim_y) - .001) {
        (*DOFx_srf)[i1] = -(*node2DOF)[2 * i0] - 2;
        (*DOFy_srf)[i1++] = -(*node2DOF)[2 * i0 + 1] - 2;
      }
    }
  }
  (*elem2loc) = (int *)malloc((*nElem) * sizeof(int));
  for (i0 = 0; i0 < (*nElem); i0++) {
    i1 = (*elem2node)[9 * i0 + 6];
    if ((*node2xy)[2 * i1 + 1] > (*dim_y) - .001 && (*node2xy)[2 * i1] > .001 &&
        (*node2xy)[2 * i1] < (*dim_x) - .001)
      (*elem2loc)[i0] = 0;
    else
      (*elem2loc)[i0] = 1;
  }
  fid = fopen("output/model_info.txt", "wt");
  fprintf(fid, "number of nodes,");
  fprintf(fid, "%i\n", *nNode);
  fprintf(fid, "number of elements,");
  fprintf(fid, "%i\n", *nElem);
  fprintf(fid, "number of degrees of freedom,");
  fprintf(fid, "%i\n", *nDOF);
  fprintf(fid, "number of surface degrees of freedom,");
  fprintf(fid, "%i\n", *nDOFsrf);
  fprintf(fid, "size of medel,");
  fprintf(fid, "%f,%f\n", *dim_x, *dim_y);
  fprintf(fid, "mesh size,");
  fprintf(fid, "%f\n", *h);
  fprintf(fid, "nodes on one side (X Y),");
  fprintf(fid, "%i,%i\n", nNodeX, nNodeY);
  fprintf(fid, "elements on one side (X Y),");
  fprintf(fid, "%i,%i\n", nElemX, nElemY);
  fclose(fid);
  fid = fopen("output/elem2node.txt", "wt");
  for (i0 = 0; i0 < *nElem; i0++) {
    for (i1 = 0; i1 < 9; i1++)
      fprintf(fid, "%i ", (*elem2node)[9 * i0 + i1]);
    fprintf(fid, "\n");
  }
  fclose(fid);
  fid = fopen("output/elem2loc.txt", "wt");
  for (i0 = 0; i0 < (*nElem); i0++)
    fprintf(fid, "%i\n", (*elem2loc)[i0]);
  fclose(fid);
  fid = fopen("output/node2DOF.txt", "wt");
  for (i0 = 0; i0 < (*nNode); i0++)
    fprintf(fid, "%i %i\n", (*node2DOF)[i0], (*node2DOF)[i0 + 1]);
  fclose(fid);
  fid = fopen("output/DOF_srf.txt", "wt");
  for (i0 = 0; i0 < (*nDOFsrf) / 2; i0++)
    fprintf(fid, "%i %i\n", (*DOFx_srf)[i0], (*DOFy_srf)[i0]);
  fclose(fid);
  fid = fopen("output/DOFx2node.txt", "wt");
  for (i0 = 0; i0 < (*nDOF) / 2; i0++)
    fprintf(fid, "%i\n", (*DOFx)[i0]);
  fclose(fid);
  fid = fopen("output/DOFy2node.txt", "wt");
  for (i0 = 0; i0 < (*nDOF) / 2; i0++)
    fprintf(fid, "%i\n", (*DOFy)[i0]);
  fclose(fid);
}


x86 assembly (clang, -O0):
<create_model>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
lea    0x1e47(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x18(%rbp),%rax
movsd  0x1e2c(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1e1c(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    0x58(%rbp),%rax
movsd  0x1e04(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x58(%rbp),%rax
divsd  (%rax),%xmm0
movsd  0x1de0(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x58(%rbp),%rax
divsd  (%rax),%xmm0
movsd  0x1dba(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%ecx
imul   -0x44(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    131c <create_model+0x19c>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1309 <create_model+0x189>
mov    -0x34(%rbp),%eax
imul   -0x44(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x54(%rbp)
cvtsi2sdl -0x34(%rbp),%xmm0
mov    0x58(%rbp),%rax
mulsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cvtsi2sdl -0x38(%rbp),%xmm0
mov    0x58(%rbp),%rax
mulsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    129b <create_model+0x11b>
jmp    130e <create_model+0x18e>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1288 <create_model+0x108>
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
imul   $0x9,(%rax),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,%rcx
mov    0x10(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    145e <create_model+0x2de>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    144b <create_model+0x2cb>
mov    -0x34(%rbp),%eax
imul   -0x4c(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x34(%rbp),%edx
shl    $0x1,%edx
imul   -0x44(%rbp),%edx
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
add    %eax,%edx
mov    0x10(%rbp),%rax
mov    (%rax),%rax
imul   $0x9,-0x50(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
shl    $0x1,%edx
add    $0x2,%edx
imul   -0x44(%rbp),%edx
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
add    %eax,%edx
mov    0x10(%rbp),%rax
mov    (%rax),%rax
imul   $0x9,-0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
shl    $0x1,%edx
add    $0x2,%edx
imul   -0x44(%rbp),%edx
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
add    $0x2,%eax
add    %eax,%edx
mov    0x10(%rbp),%rax
mov    (%rax),%rax
imul   $0x9,-0x50(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
shl    $0x1,%edx
imul   -0x44(%rbp),%edx
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
add    $0x2,%eax
add    %eax,%edx
mov    0x10(%rbp),%rax
mov    (%rax),%rax
imul   $0x9,-0x50(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1383 <create_model+0x203>
jmp    1450 <create_model+0x2d0>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1370 <create_model+0x1f0>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x30(%rbp),%rcx
cmp    (%rcx),%eax
jge    15a7 <create_model+0x427>
mov    0x10(%rbp),%rax
mov    (%rax),%rax
imul   $0x9,-0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    0x10(%rbp),%rcx
mov    (%rcx),%rcx
imul   $0x9,-0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    0x10(%rbp),%rax
mov    (%rax),%rax
imul   $0x9,-0x34(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    (%rax),%rax
imul   $0x9,-0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    0x10(%rbp),%rax
mov    (%rax),%rax
imul   $0x9,-0x34(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    (%rax),%rax
imul   $0x9,-0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    0x10(%rbp),%rcx
mov    (%rcx),%rcx
imul   $0x9,-0x34(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    0x10(%rbp),%rax
mov    (%rax),%rax
imul   $0x9,-0x34(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    (%rax),%rax
imul   $0x9,-0x34(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
sub    $0x1,%edx
mov    0x10(%rbp),%rax
mov    (%rax),%rax
imul   $0x9,-0x34(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    (%rax),%rax
imul   $0x9,-0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    0x10(%rbp),%rcx
mov    (%rcx),%rcx
imul   $0x9,-0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
add    $0x1,%edx
mov    0x10(%rbp),%rax
mov    (%rax),%rax
imul   $0x9,-0x34(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1465 <create_model+0x2e5>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,%rcx
mov    0x28(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    1602 <create_model+0x482>
mov    0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15ce <create_model+0x44e>
mov    0x20(%rbp),%rax
movl   $0x0,(%rax)
mov    0x40(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1728 <create_model+0x5a8>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x19b7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1715 <create_model+0x595>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0x1988(%rip),%xmm2
subsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1715 <create_model+0x595>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
movsd  0x1952(%rip),%xmm2
subsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1715 <create_model+0x595>
mov    0x20(%rbp),%rax
mov    (%rax),%edx
mov    %edx,%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x40(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    0x20(%rbp),%rax
mov    (%rax),%edx
mov    %edx,%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x40(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    171a <create_model+0x59a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    161d <create_model+0x49d>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1854 <create_model+0x6d4>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x18a5(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1841 <create_model+0x6c1>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0x1876(%rip),%xmm2
subsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1841 <create_model+0x6c1>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1848(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1841 <create_model+0x6c1>
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
jne    17fc <create_model+0x67c>
mov    0x20(%rbp),%rax
mov    (%rax),%edx
mov    %edx,%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
jne    183c <create_model+0x6bc>
mov    0x20(%rbp),%rax
mov    (%rax),%edx
mov    %edx,%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1841 <create_model+0x6c1>
jmp    1846 <create_model+0x6c6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    172f <create_model+0x5af>
cmpl   $0x1,-0x4(%rbp)
jne    198b <create_model+0x80b>
lea    0x17cf(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    197b <create_model+0x7fb>
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    1968 <create_model+0x7e8>
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    0x40(%rbp),%rcx
cmp    (%rcx),%eax
jge    1908 <create_model+0x788>
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
jle    1908 <create_model+0x788>
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
xor    %edx,%edx
sub    (%rax,%rcx,4),%edx
sub    $0x2,%edx
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1955 <create_model+0x7d5>
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1950 <create_model+0x7d0>
mov    0x40(%rbp),%rax
mov    (%rax),%esi
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
sub    %esi,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1955 <create_model+0x7d5>
jmp    195a <create_model+0x7da>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1889 <create_model+0x709>
jmp    196d <create_model+0x7ed>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1873 <create_model+0x6f3>
mov    0x40(%rbp),%rax
mov    (%rax),%edx
mov    0x20(%rbp),%rax
mov    (%rax),%ecx
sub    %edx,%ecx
mov    %ecx,(%rax)
mov    0x20(%rbp),%rax
mov    (%rax),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,%rcx
mov    0x30(%rbp),%rax
mov    %rcx,(%rax)
mov    0x20(%rbp),%rax
mov    (%rax),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,%rcx
mov    0x38(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x38(%rbp)
lea    0x1664(%rip),%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1080 <stat@plt>
cmp    $0x0,%rax
jne    1a0f <create_model+0x88f>
mov    -0x70(%rbp),%edi
call   1060 <S_ISDIR@plt>
cmp    $0x0,%eax
jne    1a2b <create_model+0x8ab>
lea    0x163b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x68(%rbp),%rdi
mov    $0x1ff,%esi
call   1030 <mkdir@plt>
lea    0x1647(%rip),%rdi
lea    0x1653(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1b13 <create_model+0x993>
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
jle    1b00 <create_model+0x980>
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x38(%rbp),%rax
mov    (%rax),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x38(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x60(%rbp),%rdi
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0x1596(%rip),%rsi
mov    $0x2,%al
call   1070 <fprintf@plt>
jmp    1b05 <create_model+0x985>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a49 <create_model+0x8c9>
mov    -0x60(%rbp),%rdi
call   1040 <fclose@plt>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
lea    0x1563(%rip),%rdi
mov    $0x2,%al
call   1050 <printf@plt>
mov    0x20(%rbp),%rax
mov    (%rax),%esi
lea    0x1565(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
mov    (%rax),%esi
lea    0x155d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x30(%rbp),%rax
mov    (%rax),%esi
lea    0x1555(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    0x40(%rbp),%rax
mov    (%rax),%esi
lea    0x154d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    0x40(%rbp),%rax
mov    (%rax),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,%rcx
mov    0x48(%rbp),%rax
mov    %rcx,(%rax)
mov    0x40(%rbp),%rax
mov    (%rax),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,%rcx
mov    0x50(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x38(%rbp)
cmpl   $0x0,-0x4(%rbp)
jne    1cf2 <create_model+0xb72>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1ced <create_model+0xb6d>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x13e8(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1cda <create_model+0xb5a>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0x13b9(%rip),%xmm2
subsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1cda <create_model+0xb5a>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
movsd  0x1383(%rip),%xmm2
subsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1cda <create_model+0xb5a>
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x48(%rbp),%rax
mov    (%rax),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x50(%rbp),%rax
mov    (%rax),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x38(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1cdf <create_model+0xb5f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1bec <create_model+0xa6c>
jmp    1e18 <create_model+0xc98>
cmpl   $0x1,-0x4(%rbp)
jne    1e13 <create_model+0xc93>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1e0e <create_model+0xc8e>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x12d1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1dfb <create_model+0xc7b>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0x12a2(%rip),%xmm2
subsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1dfb <create_model+0xc7b>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
movsd  0x126c(%rip),%xmm2
subsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1dfb <create_model+0xc7b>
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
xor    %edx,%edx
sub    (%rax,%rcx,4),%edx
sub    $0x2,%edx
mov    0x48(%rbp),%rax
mov    (%rax),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xor    %edx,%edx
sub    (%rax,%rcx,4),%edx
sub    $0x2,%edx
mov    0x50(%rbp),%rax
mov    (%rax),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x38(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1e00 <create_model+0xc80>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1d03 <create_model+0xb83>
jmp    1e13 <create_model+0xc93>
jmp    1e18 <create_model+0xc98>
mov    -0x30(%rbp),%rax
movslq (%rax),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,%rcx
mov    0x18(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x30(%rbp),%rcx
cmp    (%rcx),%eax
jge    1f2d <create_model+0xdad>
mov    0x10(%rbp),%rax
mov    (%rax),%rax
imul   $0x9,-0x34(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
movsd  0x1177(%rip),%xmm2
subsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1f08 <create_model+0xd88>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x114c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1f08 <create_model+0xd88>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0x111d(%rip),%xmm2
subsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1f08 <create_model+0xd88>
mov    0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    1f1a <create_model+0xd9a>
mov    0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    1f1f <create_model+0xd9f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1e3b <create_model+0xcbb>
lea    0x11a8(%rip),%rdi
lea    0x1151(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rdi
lea    0x11a3(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x60(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    (%rax),%edx
lea    0x1295(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x60(%rbp),%rdi
lea    0x118a(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x60(%rbp),%rdi
mov    -0x30(%rbp),%rax
mov    (%rax),%edx
lea    0x126b(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x60(%rbp),%rdi
lea    0x1174(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x60(%rbp),%rdi
mov    0x20(%rbp),%rax
mov    (%rax),%edx
lea    0x1241(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x60(%rbp),%rdi
lea    0x1168(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x60(%rbp),%rdi
mov    0x40(%rbp),%rax
mov    (%rax),%edx
lea    0x1217(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x60(%rbp),%rdi
lea    0x1164(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x60(%rbp),%rdi
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
lea    0x1151(%rip),%rsi
mov    $0x2,%al
call   1070 <fprintf@plt>
mov    -0x60(%rbp),%rdi
lea    0x1146(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x60(%rbp),%rdi
mov    0x58(%rbp),%rax
movsd  (%rax),%xmm0
lea    0x1128(%rip),%rsi
mov    $0x1,%al
call   1070 <fprintf@plt>
mov    -0x60(%rbp),%rdi
lea    0x1125(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x60(%rbp),%rdi
mov    -0x40(%rbp),%edx
mov    -0x44(%rbp),%ecx
lea    0x1126(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x60(%rbp),%rdi
lea    0x111b(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x60(%rbp),%rdi
mov    -0x48(%rbp),%edx
mov    -0x4c(%rbp),%ecx
lea    0x10fc(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x60(%rbp),%rdi
call   1040 <fclose@plt>
lea    0x1108(%rip),%rdi
lea    0xfd5(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x30(%rbp),%rcx
cmp    (%rcx),%eax
jge    213b <create_model+0xfbb>
movl   $0x0,-0x38(%rbp)
cmpl   $0x9,-0x38(%rbp)
jge    211b <create_model+0xf9b>
mov    -0x60(%rbp),%rdi
mov    0x10(%rbp),%rax
mov    (%rax),%rax
imul   $0x9,-0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
lea    0x10c7(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    20dd <create_model+0xf5d>
mov    -0x60(%rbp),%rdi
lea    0xf0c(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    20c7 <create_model+0xf47>
mov    -0x60(%rbp),%rdi
call   1040 <fclose@plt>
lea    0x1086(%rip),%rdi
lea    0xf3a(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x30(%rbp),%rcx
cmp    (%rcx),%eax
jge    219f <create_model+0x101f>
mov    -0x60(%rbp),%rdi
mov    0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
lea    0x1072(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2162 <create_model+0xfe2>
mov    -0x60(%rbp),%rdi
call   1040 <fclose@plt>
lea    0x1036(%rip),%rdi
lea    0xed6(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    2216 <create_model+0x1096>
mov    -0x60(%rbp),%rdi
mov    0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
lea    0xff8(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    21c6 <create_model+0x1046>
mov    -0x60(%rbp),%rdi
call   1040 <fclose@plt>
lea    0xfda(%rip),%rdi
lea    0xe5f(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    0x40(%rbp),%rax
mov    (%rax),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x74(%rbp),%eax
cmp    %ecx,%eax
jge    229a <create_model+0x111a>
mov    -0x60(%rbp),%rdi
mov    0x48(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x50(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
lea    0xf74(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    223d <create_model+0x10bd>
mov    -0x60(%rbp),%rdi
call   1040 <fclose@plt>
lea    0xf69(%rip),%rdi
lea    0xddb(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    0x20(%rbp),%rax
mov    (%rax),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x78(%rbp),%eax
cmp    %ecx,%eax
jge    2310 <create_model+0x1190>
mov    -0x60(%rbp),%rdi
mov    0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
lea    0xf01(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    22c1 <create_model+0x1141>
mov    -0x60(%rbp),%rdi
call   1040 <fclose@plt>
lea    0xf08(%rip),%rdi
lea    0xd65(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    0x20(%rbp),%rax
mov    (%rax),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x7c(%rbp),%eax
cmp    %ecx,%eax
jge    2386 <create_model+0x1206>
mov    -0x60(%rbp),%rdi
mov    0x38(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
lea    0xe8b(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2337 <create_model+0x11b7>
mov    -0x60(%rbp),%rdi
call   1040 <fclose@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<create_model>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r9,0x40(%rsp)
mov    %r8,%r13
mov    %rcx,%rbp
mov    %rdx,%rbx
mov    %rsi,%r12
mov    %edi,0x3c(%rsp)
mov    0x108(%rsp),%r15
lea    0x2001(%rip),%rdi
call   1040 <puts@plt>
movabs $0x4044000000000000,%rax
mov    %rax,(%rbx)
mov    %rax,0x0(%rbp)
movabs $0x3fb999999999999a,%rax
99 b9 3f
mov    %rax,(%r15)
mov    %rbx,0x50(%rsp)
movsd  (%rbx),%xmm0
movsd  0x1de7(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  0x1de3(%rip),%xmm2
addsd  %xmm2,%xmm0
cvttsd2si %xmm0,%esi
lea    0x1(%rsi),%eax
mov    %rbp,0x18(%rsp)
movsd  0x0(%rbp),%xmm0
divsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
cvttsd2si %xmm0,%edx
mov    %rdx,0x30(%rsp)
lea    0x1(%rdx),%r14d
mov    %r14d,%edi
mov    %eax,0x4c(%rsp)
imul   %eax,%edi
mov    %r12,0x10(%rsp)
mov    %edi,(%r12)
mov    %rsi,%r12
shl    $0x4,%edi
call   10b0 <malloc@plt>
mov    %r13,0x28(%rsp)
mov    %rax,0x0(%r13)
test   %r12d,%r12d
mov    %r14d,0x8(%rsp)
js     14d8 <create_model+0x328>
mov    %rax,%rcx
mov    %r14d,%edi
lea    -0x1(%rdi),%rsi
mov    0x30(%rsp),%rax
lea    (%rax,%rax,1),%ebp
add    $0x2,%ebp
lea    0x8(%rcx),%rax
mov    %rax,0x80(%rsp)
lea    0x8(%r15),%rax
mov    %rax,0x58(%rsp)
mov    %rdi,%rax
shl    $0x4,%rax
add    %rcx,%rax
mov    %rax,0x60(%rsp)
mov    %esi,%eax
add    %eax,%eax
mov    %rax,0x78(%rsp)
setb   0xc(%rsp)
mov    $0x10,%edx
mov    %rsi,0x68(%rsp)
mov    %rsi,%rax
mul    %rdx
mov    %rax,0x70(%rsp)
mov    %ebp,%eax
seto   0x7(%rsp)
mov    %edi,%r9d
and    $0xfffffffe,%r9d
mov    $0x1,%r10d
xor    %edx,%edx
xor    %r11d,%r11d
mov    %ebp,(%rsp)
mov    %r12,0x20(%rsp)
jmp    1326 <create_model+0x176>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x1(%r11),%esi
add    %eax,%r10d
add    %r14d,%edx
cmp    %r12d,%r11d
mov    %esi,%r11d
je     14d8 <create_model+0x328>
cmpl   $0x0,0x30(%rsp)
js     1310 <create_model+0x160>
xorps  %xmm0,%xmm0
cvtsi2sd %r11d,%xmm0
cmp    $0x2,%r14d
jae    1390 <create_model+0x1e0>
xor    %esi,%esi
lea    (%rdx,%rsi,1),%ebx
add    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r15),%xmm1
mulsd  %xmm0,%xmm1
movslq %ebx,%rbx
movsd  %xmm1,(%rcx,%rbx,8)
xorps  %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
mulsd  (%r15),%xmm1
lea    0x1(%rbx),%ebp
movslq %ebp,%rbp
movsd  %xmm1,(%rcx,%rbp,8)
add    $0x1,%rsi
add    $0x2,%ebx
cmp    %rsi,%rdi
jne    1350 <create_model+0x1a0>
jmp    1310 <create_model+0x160>
cs nopw 0x0(%rax,%rax,1)
mov    %eax,%esi
imul   %r11d,%esi
movslq %esi,%r13
or     $0x1,%esi
lea    (%rcx,%r13,8),%r8
mov    0x80(%rsp),%rbx
lea    (%rbx,%r13,8),%r14
mov    0x78(%rsp),%rax
lea    (%rax,%r13,1),%ebp
cmp    %r13d,%ebp
setl   %bl
or     0xc(%rsp),%bl
lea    (%rsi,%rax,1),%ebp
cmp    %esi,%ebp
setl   %bpl
mov    0x70(%rsp),%rax
lea    (%r8,%rax,1),%rsi
cmp    %r8,%rsi
setb   %r12b
lea    (%r14,%rax,1),%rsi
cmp    %r14,%rsi
setb   %sil
test   %bl,%bl
jne    14c0 <create_model+0x310>
mov    0x68(%rsp),%r14
shr    $0x20,%r14
jne    14c0 <create_model+0x310>
or     0xc(%rsp),%bpl
jne    14c0 <create_model+0x310>
test   %r14,%r14
jne    14c0 <create_model+0x310>
mov    0x7(%rsp),%al
or     %al,%r12b
mov    0x8(%rsp),%r14d
jne    14c9 <create_model+0x319>
or     %al,%sil
mov    $0x0,%esi
mov    0x20(%rsp),%r12
mov    (%rsp),%eax
jne    133d <create_model+0x18d>
mov    0x60(%rsp),%rsi
lea    (%rsi,%r13,8),%rsi
cmp    %r15,%rsi
jbe    144f <create_model+0x29f>
cmp    0x58(%rsp),%r8
jb     133b <create_model+0x18b>
mov    %r10d,%esi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movd   %ebx,%xmm1
lea    0x1(%rbx),%ebp
movd   %ebp,%xmm2
punpckldq %xmm2,%xmm1
movsd  (%r15),%xmm2
movapd %xmm2,%xmm3
mulsd  %xmm0,%xmm3
cvtdq2pd %xmm1,%xmm1
unpcklpd %xmm2,%xmm2
mulpd  %xmm1,%xmm2
movslq %esi,%rsi
movapd %xmm3,%xmm1
unpcklpd %xmm2,%xmm1
movsd  %xmm3,%xmm2
movupd %xmm2,0x8(%rcx,%rsi,8)
movupd %xmm1,-0x8(%rcx,%rsi,8)
add    $0x2,%rbx
add    $0x4,%esi
cmp    %rbx,%r9
jne    1460 <create_model+0x2b0>
mov    %r9,%rsi
cmp    %rdi,%r9
je     1310 <create_model+0x160>
jmp    133d <create_model+0x18d>
xor    %esi,%esi
mov    0x8(%rsp),%r14d
jmp    14cb <create_model+0x31b>
xor    %esi,%esi
mov    0x20(%rsp),%r12
mov    (%rsp),%eax
jmp    133d <create_model+0x18d>
mov    %r12d,%ecx
shr    $0x1f,%ecx
add    %r12d,%ecx
sar    %ecx
mov    0x30(%rsp),%rdx
mov    %edx,%eax
shr    $0x1f,%eax
add    %edx,%eax
sar    %eax
mov    %eax,(%rsp)
mov    %ecx,0xc(%rsp)
imul   %ecx,%eax
mov    0x40(%rsp),%rcx
mov    %eax,(%rcx)
shl    $0x2,%eax
lea    (%rax,%rax,8),%edi
call   10b0 <malloc@plt>
mov    0xc0(%rsp),%rcx
mov    %rax,(%rcx)
cmp    $0x2,%r12d
mov    0x10(%rsp),%r13
jl     15a0 <create_model+0x3f0>
movslq (%rsp),%rcx
mov    0xc(%rsp),%r8d
mov    %ecx,%r9d
lea    0xc(%rax),%r11
shl    $0x2,%rcx
lea    (%rcx,%rcx,8),%r10
mov    0x30(%rsp),%rcx
lea    (%rcx,%rcx,1),%ebx
add    $0x2,%ebx
add    %ecx,%ecx
add    $0x4,%ecx
xor    %r14d,%r14d
xor    %r12d,%r12d
jmp    156f <create_model+0x3bf>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r12
add    %r10,%r11
add    %ebx,%r14d
cmp    %r8,%r12
je     15a0 <create_model+0x3f0>
mov    %r9,%rbp
mov    %r14d,%edx
mov    %r11,%rsi
cmpl   $0x2,0x30(%rsp)
jl     1560 <create_model+0x3b0>
nop
mov    %edx,-0xc(%rsi)
lea    (%rbx,%rdx,1),%edi
mov    %edi,-0x8(%rsi)
lea    (%rcx,%rdx,1),%edi
mov    %edi,-0x4(%rsi)
add    $0x2,%edx
mov    %edx,(%rsi)
add    $0x24,%rsi
add    $0xffffffffffffffff,%rbp
jne    1580 <create_model+0x3d0>
jmp    1560 <create_model+0x3b0>
mov    0xd8(%rsp),%r12
mov    0x40(%rsp),%rbx
cmpl   $0x0,(%rbx)
jle    1609 <create_model+0x459>
add    $0x20,%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
mov    -0x1c(%rax),%edx
mov    -0x14(%rax),%esi
mov    -0x20(%rax),%ebp
add    %edx,%ebp
mov    %ebp,%edi
shr    $0x1f,%edi
add    %ebp,%edi
sar    %edi
mov    %edi,-0x10(%rax)
add    $0x1,%edx
mov    %edx,-0xc(%rax)
mov    -0x18(%rax),%ebp
add    %esi,%ebp
mov    %ebp,%edx
shr    $0x1f,%edx
add    %ebp,%edx
sar    %edx
mov    %edx,-0x8(%rax)
add    $0xffffffff,%esi
mov    %esi,-0x4(%rax)
add    $0x1,%edi
mov    %edi,(%rax)
add    $0x1,%rcx
movslq (%rbx),%rdx
add    $0x24,%rax
cmp    %rdx,%rcx
jl     15c0 <create_model+0x410>
mov    0xd0(%rsp),%r14
mov    0x0(%r13),%edi
shl    $0x3,%edi
call   10b0 <malloc@plt>
mov    %rax,(%r12)
cmpl   $0x0,0x0(%r13)
mov    0x50(%rsp),%rbx
jle    1647 <create_model+0x497>
xor    %ecx,%ecx
nop
movl   $0xffffffff,(%rax,%rcx,4)
add    $0x1,%rcx
movslq 0x0(%r13),%rdx
add    %rdx,%rdx
cmp    %rdx,%rcx
jl     1630 <create_model+0x480>
movl   $0x0,(%r14)
mov    0xf0(%rsp),%rcx
movl   $0x0,(%rcx)
mov    0x0(%r13),%esi
test   %esi,%esi
mov    0x18(%rsp),%r8
movsd  0x1999(%rip),%xmm3
jle    1784 <create_model+0x5d4>
mov    0x28(%rsp),%rcx
mov    (%rcx),%rcx
add    $0x8,%rcx
xor    %edx,%edx
movsd  0x1985(%rip),%xmm0
jmp    16a0 <create_model+0x4f0>
nopl   (%rax)
add    $0x1,%rdx
movslq %esi,%rdi
add    $0x10,%rcx
cmp    %rdi,%rdx
jge    16fb <create_model+0x54b>
movsd  -0x8(%rcx),%xmm1
ucomisd %xmm3,%xmm1
jbe    1690 <create_model+0x4e0>
movsd  (%rbx),%xmm2
addsd  %xmm0,%xmm2
ucomisd %xmm1,%xmm2
jbe    1690 <create_model+0x4e0>
movsd  (%rcx),%xmm1
movsd  (%r8),%xmm2
addsd  %xmm0,%xmm2
ucomisd %xmm2,%xmm1
jbe    1690 <create_model+0x4e0>
mov    (%r14),%esi
lea    0x1(%rsi),%edi
mov    %edi,(%r14)
mov    %esi,(%rax,%rdx,8)
mov    0xf0(%rsp),%rbp
addl   $0x1,0x0(%rbp)
mov    (%r14),%esi
lea    0x1(%rsi),%edi
mov    %edi,(%r14)
mov    %esi,0x4(%rax,%rdx,8)
addl   $0x1,0x0(%rbp)
mov    0x0(%r13),%esi
jmp    1690 <create_model+0x4e0>
test   %esi,%esi
jle    1784 <create_model+0x5d4>
mov    0x28(%rsp),%rcx
mov    (%rcx),%rcx
add    $0x8,%rcx
xor    %edx,%edx
jmp    1741 <create_model+0x591>
mov    (%r14),%edi
lea    0x1(%rdi),%ebp
mov    %ebp,(%r14)
mov    %edi,(%rax,%rsi,4)
cmpl   $0xffffffff,0x4(%rax,%rdx,8)
je     1775 <create_model+0x5c5>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rdx
movslq 0x0(%r13),%rsi
add    $0x10,%rcx
cmp    %rsi,%rdx
jge    1784 <create_model+0x5d4>
movsd  -0x8(%rcx),%xmm1
ucomisd %xmm3,%xmm1
jbe    1730 <create_model+0x580>
movsd  (%rbx),%xmm2
addsd  %xmm0,%xmm2
ucomisd %xmm1,%xmm2
jbe    1730 <create_model+0x580>
movsd  (%rcx),%xmm1
ucomisd %xmm3,%xmm1
jbe    1730 <create_model+0x580>
lea    (%rdx,%rdx,1),%rsi
cmpl   $0xffffffff,(%rax,%rdx,8)
je     1713 <create_model+0x563>
cmpl   $0xffffffff,0x4(%rax,%rdx,8)
jne    1730 <create_model+0x580>
mov    (%r14),%edi
lea    0x1(%rdi),%ebp
mov    %ebp,(%r14)
mov    %edi,0x4(%rax,%rsi,4)
jmp    1730 <create_model+0x580>
cmpl   $0x1,0x3c(%rsp)
jne    180c <create_model+0x65c>
lea    0x1a92(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,0x0(%r13)
jle    1811 <create_model+0x661>
mov    (%r12),%rax
xor    %ecx,%ecx
jmp    17ca <create_model+0x61a>
nopw   0x0(%rax,%rax,1)
mov    $0xfffffffe,%edi
sub    %esi,%edi
mov    %edi,%esi
mov    %esi,0x4(%rax,%rdx,4)
add    $0x1,%rcx
movslq 0x0(%r13),%rdx
cmp    %rdx,%rcx
jge    1811 <create_model+0x661>
lea    (%rcx,%rcx,1),%rdx
mov    (%rax,%rcx,8),%esi
mov    0xf0(%rsp),%rbp
mov    0x0(%rbp),%edi
test   %esi,%esi
js     17f0 <create_model+0x640>
cmp    %edi,%esi
jge    17f0 <create_model+0x640>
mov    $0xfffffffe,%edi
sub    %esi,%edi
mov    %edi,%esi
jmp    17f4 <create_model+0x644>
nop
sub    %edi,%esi
jl     17f7 <create_model+0x647>
mov    %esi,(%rax,%rdx,4)
mov    0x4(%rax,%rcx,8),%esi
mov    0x0(%rbp),%edi
test   %esi,%esi
js     1806 <create_model+0x656>
cmp    %edi,%esi
jl     17b0 <create_model+0x600>
sub    %edi,%esi
jge    17b9 <create_model+0x609>
jmp    17bd <create_model+0x60d>
mov    (%r14),%eax
jmp    1821 <create_model+0x671>
mov    (%r14),%eax
mov    0xf0(%rsp),%rcx
sub    (%rcx),%eax
mov    %eax,(%r14)
mov    %eax,%edi
shr    $0x1f,%edi
add    %eax,%edi
add    %edi,%edi
and    $0xfffffffc,%edi
call   10b0 <malloc@plt>
mov    0xe0(%rsp),%rcx
mov    %rax,(%rcx)
mov    (%r14),%eax
mov    %eax,%edi
shr    $0x1f,%edi
add    %eax,%edi
add    %edi,%edi
and    $0xfffffffc,%edi
call   10b0 <malloc@plt>
mov    0xe8(%rsp),%rcx
mov    %rax,(%rcx)
lea    0x17b5(%rip),%rdi
lea    0x48(%rsp),%rsi
call   10a0 <stat@plt>
test   %rax,%rax
je     1891 <create_model+0x6e1>
lea    0x1988(%rip),%rdi
call   1040 <puts@plt>
lea    0x1793(%rip),%rdi
mov    $0x1ff,%esi
call   1030 <mkdir@plt>
jmp    189e <create_model+0x6ee>
mov    0x48(%rsp),%edi
call   1070 <S_ISDIR@plt>
test   %eax,%eax
je     1872 <create_model+0x6c2>
lea    0x177d(%rip),%rdi
lea    0x1789(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,%r14
mov    0x0(%r13),%eax
test   %eax,%eax
jle    1955 <create_model+0x7a5>
xor    %ebx,%ebx
mov    $0x4,%r12d
lea    0x1769(%rip),%r13
xor    %ebp,%ebp
jmp    18f0 <create_model+0x740>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rbx
movslq %eax,%rcx
add    $0x8,%r12
cmp    %rcx,%rbx
jge    1955 <create_model+0x7a5>
mov    0xd8(%rsp),%rcx
mov    (%rcx),%rcx
mov    -0x4(%rcx,%r12,1),%edx
test   %edx,%edx
js     18e0 <create_model+0x730>
mov    0xe0(%rsp),%rax
mov    (%rax),%rax
movslq %ebp,%rsi
mov    %edx,(%rax,%rsi,4)
mov    (%rcx,%r12,1),%eax
mov    0xe8(%rsp),%rcx
mov    (%rcx),%rcx
lea    0x1(%rsi),%ebp
mov    %eax,(%rcx,%rsi,4)
mov    0x28(%rsp),%rax
mov    (%rax),%rax
movsd  -0x8(%rax,%r12,2),%xmm0
movsd  (%rax,%r12,2),%xmm1
mov    %r14,%rdi
mov    %r13,%rsi
mov    $0x2,%al
call   1090 <fprintf@plt>
mov    0x10(%rsp),%rax
mov    (%rax),%eax
jmp    18e0 <create_model+0x730>
mov    %r14,%rdi
call   1050 <fclose@plt>
mov    0x50(%rsp),%r14
movsd  (%r14),%xmm0
mov    0x18(%rsp),%rax
movsd  (%rax),%xmm1
lea    0x16c8(%rip),%rdi
mov    $0x2,%al
call   1060 <printf@plt>
mov    0xd0(%rsp),%rax
mov    (%rax),%esi
lea    0x16c6(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x10(%rsp),%rbx
mov    (%rbx),%esi
lea    0x16bd(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x40(%rsp),%r13
mov    0x0(%r13),%esi
lea    0x16b2(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0xf0(%rsp),%rbp
mov    0x0(%rbp),%esi
lea    0x16a5(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x0(%rbp),%eax
mov    %eax,%edi
shr    $0x1f,%edi
add    %eax,%edi
add    %edi,%edi
and    $0xfffffffc,%edi
call   10b0 <malloc@plt>
mov    0xf8(%rsp),%rcx
mov    %rax,(%rcx)
mov    0x0(%rbp),%eax
mov    %eax,%edi
shr    $0x1f,%edi
add    %eax,%edi
add    %edi,%edi
and    $0xfffffffc,%edi
call   10b0 <malloc@plt>
mov    0x100(%rsp),%rcx
mov    %rax,(%rcx)
mov    0x3c(%rsp),%ecx
test   %ecx,%ecx
je     1b05 <create_model+0x955>
cmp    $0x1,%ecx
mov    0xc0(%rsp),%r12
movsd  0x15d0(%rip),%xmm3
mov    0xf8(%rsp),%r9
mov    0x18(%rsp),%rbx
jne    1bc4 <create_model+0xa14>
mov    0x10(%rsp),%rcx
mov    (%rcx),%esi
test   %esi,%esi
jle    1bc4 <create_model+0xa14>
mov    0x28(%rsp),%rcx
mov    (%rcx),%rcx
add    $0x8,%rcx
xor    %edx,%edx
movsd  0x15a0(%rip),%xmm0
xor    %r8d,%r8d
jmp    1a94 <create_model+0x8e4>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdx
movslq %esi,%rdi
add    $0x10,%rcx
cmp    %rdi,%rdx
jge    1bc4 <create_model+0xa14>
movsd  -0x8(%rcx),%xmm1
ucomisd %xmm3,%xmm1
jbe    1a80 <create_model+0x8d0>
movsd  (%r14),%xmm2
addsd  %xmm0,%xmm2
ucomisd %xmm1,%xmm2
jbe    1a80 <create_model+0x8d0>
movsd  (%rcx),%xmm1
movsd  (%rbx),%xmm2
addsd  %xmm0,%xmm2
ucomisd %xmm2,%xmm1
jbe    1a80 <create_model+0x8d0>
mov    0xd8(%rsp),%rsi
mov    (%rsi),%rsi
mov    $0xfffffffe,%ebp
sub    (%rsi,%rdx,8),%ebp
mov    (%r9),%rbx
movslq %r8d,%rdi
mov    %ebp,(%rbx,%rdi,4)
mov    0x18(%rsp),%rbx
mov    0xc0(%rsp),%r12
mov    $0xfffffffe,%ebp
sub    0x4(%rsi,%rdx,8),%ebp
lea    0x1(%rdi),%r8d
mov    %ebp,(%rax,%rdi,4)
mov    0x10(%rsp),%rsi
mov    (%rsi),%esi
jmp    1a80 <create_model+0x8d0>
mov    (%rbx),%esi
test   %esi,%esi
mov    0xc0(%rsp),%r12
movsd  0x14ef(%rip),%xmm3
mov    0xf8(%rsp),%r9
mov    0x18(%rsp),%rbx
jle    1bc4 <create_model+0xa14>
mov    0x28(%rsp),%rcx
mov    (%rcx),%rcx
add    $0x8,%rcx
xor    %edx,%edx
movsd  0x14ce(%rip),%xmm0
xor    %r8d,%r8d
jmp    1b60 <create_model+0x9b0>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
movslq %esi,%rdi
add    $0x10,%rcx
cmp    %rdi,%rdx
jge    1bc4 <create_model+0xa14>
movsd  -0x8(%rcx),%xmm1
ucomisd %xmm3,%xmm1
jbe    1b50 <create_model+0x9a0>
movsd  (%r14),%xmm2
addsd  %xmm0,%xmm2
ucomisd %xmm1,%xmm2
jbe    1b50 <create_model+0x9a0>
movsd  (%rcx),%xmm1
movsd  (%rbx),%xmm2
addsd  %xmm0,%xmm2
ucomisd %xmm2,%xmm1
jbe    1b50 <create_model+0x9a0>
mov    0xd8(%rsp),%rsi
mov    (%rsi),%rsi
mov    (%rsi,%rdx,8),%ebp
mov    (%r9),%rbx
movslq %r8d,%rdi
mov    %ebp,(%rbx,%rdi,4)
mov    0x18(%rsp),%rbx
mov    0xc0(%rsp),%r12
mov    0x4(%rsi,%rdx,8),%esi
lea    0x1(%rdi),%r8d
mov    %esi,(%rax,%rdi,4)
mov    0x10(%rsp),%rsi
mov    (%rsi),%esi
jmp    1b50 <create_model+0x9a0>
mov    0x0(%r13),%edi
shl    $0x2,%edi
call   10b0 <malloc@plt>
movsd  0x1430(%rip),%xmm4
mov    0xc8(%rsp),%rcx
mov    %rax,(%rcx)
cmpl   $0x0,0x0(%r13)
jle    1c73 <create_model+0xac3>
mov    (%r12),%rcx
movsd  (%rbx),%xmm0
addsd  0x1412(%rip),%xmm0
mov    0x28(%rsp),%rdx
mov    (%rdx),%rdx
add    $0x18,%rcx
xor    %esi,%esi
movsd  0x13fc(%rip),%xmm1
jmp    1c39 <create_model+0xa89>
cs nopw 0x0(%rax,%rax,1)
mov    $0x1,%edi
mov    %edi,(%rax,%rsi,4)
add    $0x1,%rsi
movslq 0x0(%r13),%rdi
add    $0x24,%rcx
cmp    %rdi,%rsi
jge    1c73 <create_model+0xac3>
movslq (%rcx),%rbp
mov    %rbp,%rdi
shl    $0x4,%rdi
movsd  0x8(%rdx,%rdi,1),%xmm2
ucomisd %xmm0,%xmm2
jbe    1c20 <create_model+0xa70>
add    %rbp,%rbp
movslq %ebp,%rdi
movsd  (%rdx,%rdi,8),%xmm2
ucomisd %xmm4,%xmm2
jbe    1c20 <create_model+0xa70>
movsd  (%r14),%xmm3
addsd  %xmm1,%xmm3
xor    %edi,%edi
ucomisd %xmm2,%xmm3
jbe    1c20 <create_model+0xa70>
jmp    1c25 <create_model+0xa75>
lea    0x140b(%rip),%rdi
lea    0x13b4(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,%rbp
lea    0x140b(%rip),%rdi
mov    $0x10,%esi
mov    $0x1,%edx
mov    %rax,%rcx
call   10d0 <fwrite@plt>
mov    0x10(%rsp),%rax
mov    (%rax),%edx
lea    0x14f5(%rip),%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
lea    0x13e8(%rip),%rdi
mov    $0x13,%esi
mov    $0x1,%edx
mov    %rbp,%rcx
call   10d0 <fwrite@plt>
mov    0x0(%r13),%edx
mov    %rbp,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
lea    0x13d2(%rip),%rdi
mov    $0x1d,%esi
mov    $0x1,%edx
mov    %rbp,%rcx
call   10d0 <fwrite@plt>
mov    0xd0(%rsp),%rax
mov    (%rax),%edx
mov    %rbp,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
lea    0x13c0(%rip),%rdi
mov    $0x25,%esi
mov    $0x1,%edx
mov    %rbp,%rcx
call   10d0 <fwrite@plt>
mov    0xf0(%rsp),%rax
mov    (%rax),%edx
mov    %rbp,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
lea    0x13b6(%rip),%rdi
mov    $0xe,%esi
mov    $0x1,%edx
mov    %rbp,%rcx
call   10d0 <fwrite@plt>
movsd  (%r14),%xmm0
mov    0x18(%rsp),%rax
movsd  (%rax),%xmm1
lea    0x139e(%rip),%rsi
mov    %rbp,%rdi
mov    $0x2,%al
call   1090 <fprintf@plt>
lea    0x1394(%rip),%rdi
mov    $0xa,%esi
mov    $0x1,%edx
mov    %rbp,%rcx
call   10d0 <fwrite@plt>
movsd  (%r15),%xmm0
lea    0x1372(%rip),%rsi
mov    %rbp,%rdi
mov    $0x1,%al
call   1090 <fprintf@plt>
lea    0x1370(%rip),%rdi
mov    $0x18,%esi
mov    $0x1,%edx
mov    %rbp,%rcx
call   10d0 <fwrite@plt>
lea    0x1370(%rip),%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    0x4c(%rsp),%edx
mov    0x8(%rsp),%ecx
xor    %eax,%eax
call   1090 <fprintf@plt>
lea    0x135b(%rip),%rdi
mov    $0x1b,%esi
mov    $0x1,%edx
mov    %rbp,%rcx
call   10d0 <fwrite@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    0xc(%rsp),%edx
mov    (%rsp),%ecx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    %rbp,%rdi
call   1050 <fclose@plt>
lea    0x1342(%rip),%rdi
lea    0x120f(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,%rbp
cmpl   $0x0,0x0(%r13)
jle    1f2e <create_model+0xd7e>
lea    0x1336(%rip),%r15
xor    %ebx,%ebx
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r12),%rax
mov    (%rax,%rbx,1),%edx
mov    %rbp,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r12),%rax
mov    0x4(%rax,%rbx,1),%edx
mov    %rbp,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r12),%rax
mov    0x8(%rax,%rbx,1),%edx
mov    %rbp,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r12),%rax
mov    0xc(%rax,%rbx,1),%edx
mov    %rbp,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r12),%rax
mov    0x10(%rax,%rbx,1),%edx
mov    %rbp,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r12),%rax
mov    0x14(%rax,%rbx,1),%edx
mov    %rbp,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r12),%rax
mov    0x18(%rax,%rbx,1),%edx
mov    %rbp,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r12),%rax
mov    0x1c(%rax,%rbx,1),%edx
mov    %rbp,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r12),%rax
mov    0x20(%rax,%rbx,1),%edx
mov    %rbp,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    $0xa,%edi
mov    %rbp,%rsi
call   1080 <fputc@plt>
add    $0x1,%r14
movslq 0x0(%r13),%rax
add    $0x24,%rbx
cmp    %rax,%r14
jl     1e50 <create_model+0xca0>
mov    %rbp,%rdi
call   1050 <fclose@plt>
lea    0x123d(%rip),%rdi
lea    0x10f1(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,%rbx
cmpl   $0x0,0x0(%r13)
mov    0xc8(%rsp),%r15
jle    1f90 <create_model+0xde0>
lea    0x1243(%rip),%r14
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r15),%rax
mov    (%rax,%rbp,4),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
add    $0x1,%rbp
movslq 0x0(%r13),%rax
cmp    %rax,%rbp
jl     1f70 <create_model+0xdc0>
mov    %rbx,%rdi
call   1050 <fclose@plt>
lea    0x11ef(%rip),%rdi
lea    0x108f(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,%r13
mov    0x10(%rsp),%rbx
cmpl   $0x0,(%rbx)
mov    0xd8(%rsp),%r12
jle    1ff7 <create_model+0xe47>
lea    0x11db(%rip),%r14
xor    %eax,%eax
nopl   0x0(%rax)
mov    (%r12),%rcx
lea    0x1(%rax),%rbp
mov    (%rcx,%rax,4),%edx
mov    0x4(%rcx,%rax,4),%ecx
mov    %r13,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
movslq (%rbx),%rcx
mov    %rbp,%rax
cmp    %rcx,%rbp
jl     1fd0 <create_model+0xe20>
mov    %r13,%rdi
call   1050 <fclose@plt>
lea    0x11a3(%rip),%rdi
lea    0x1028(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,%rbx
mov    0xf0(%rsp),%r12
cmpl   $0x2,(%r12)
mov    0x100(%rsp),%r13
mov    0xf8(%rsp),%r15
jl     2073 <create_model+0xec3>
lea    0x1167(%rip),%r14
xor    %ebp,%ebp
nopl   (%rax)
mov    (%r15),%rax
mov    (%rax,%rbp,4),%edx
mov    0x0(%r13),%rax
mov    (%rax,%rbp,4),%ecx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
add    $0x1,%rbp
mov    (%r12),%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
movslq %ecx,%rax
cmp    %rax,%rbp
jl     2040 <create_model+0xe90>
mov    %rbx,%rdi
call   1050 <fclose@plt>
lea    0x113a(%rip),%rdi
lea    0xfac(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,%rbx
mov    0xd0(%rsp),%r15
cmpl   $0x2,(%r15)
mov    0xe0(%rsp),%r12
jl     20dc <create_model+0xf2c>
lea    0x10f7(%rip),%r14
xor    %ebp,%ebp
mov    (%r12),%rax
mov    (%rax,%rbp,4),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
add    $0x1,%rbp
mov    (%r15),%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
movslq %ecx,%rax
cmp    %rax,%rbp
jl     20b0 <create_model+0xf00>
mov    %rbx,%rdi
call   1050 <fclose@plt>
lea    0x10e6(%rip),%rdi
lea    0xf43(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,%rbx
cmpl   $0x2,(%r15)
mov    0xe8(%rsp),%r12
jl     214c <create_model+0xf9c>
lea    0x1096(%rip),%r14
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r12),%rax
mov    (%rax,%rbp,4),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
add    $0x1,%rbp
mov    (%r15),%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
movslq %ecx,%rax
cmp    %rax,%rbp
jl     2120 <create_model+0xf70>
mov    %rbx,%rdi
call   1050 <fclose@plt>
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
%struct.stat = type { i32 }
@.str.2 = [10 x i8] c"./output/\00"
@.str.4 = [19 x i8] c"output/node2xy.txt\00"
@.str.5 = [3 x i8] c"wt\00"
@.str.6 = [7 x i8] c"%e %e\0A\00"
@.str.7 = [22 x i8] c" dim x=%f, dim y=%f\0A\00"
@.str.8 = [12 x i8] c" nDOF=%i\0A\00"
@.str.9 = [12 x i8] c" nNode=%i\0A\00"
@.str.10 = [12 x i8] c" nElem=%i\0A\00"
@.str.11 = [12 x i8] c"nDOFsrf=%i\0A\00"
@.str.12 = [22 x i8] c"output/model_info.txt\00"
@.str.13 = [17 x i8] c"number of nodes,\00"
@.str.14 = [4 x i8] c"%i\0A\00"
@.str.15 = [20 x i8] c"number of elements,\00"
@.str.16 = [30 x i8] c"number of degrees of freedom,\00"
@.str.17 = [38 x i8] c"number of surface degrees of freedom,\00"
@.str.18 = [15 x i8] c"size of medel,\00"
@.str.19 = [7 x i8] c"%f,%f\0A\00"
@.str.20 = [11 x i8] c"mesh size,\00"
@.str.21 = [4 x i8] c"%f\0A\00"
@.str.22 = [25 x i8] c"nodes on one side (X Y),\00"
@.str.23 = [7 x i8] c"%i,%i\0A\00"
@.str.24 = [28 x i8] c"elements on one side (X Y),\00"
@.str.25 = [21 x i8] c"output/elem2node.txt\00"
@.str.26 = [4 x i8] c"%i \00"
@.str.28 = [20 x i8] c"output/elem2loc.txt\00"
@.str.29 = [20 x i8] c"output/node2DOF.txt\00"
@.str.30 = [7 x i8] c"%i %i\0A\00"
@.str.31 = [19 x i8] c"output/DOF_srf.txt\00"
@.str.32 = [21 x i8] c"output/DOFx2node.txt\00"
@.str.33 = [21 x i8] c"output/DOFy2node.txt\00"
@str = [27 x i8] c"----- creating model -----\00"
@str.34 = [39 x i8] c"Output foler does not exist. Creating.\00"
@str.35 = [18 x i8] c" adjusting DOF...\00"
define void @create_model(i32 %0, i32* nocapture %1, double* nocapture %2, double* nocapture %3, double** nocapture %4, i32* nocapture %5, i32** nocapture %6, i32** nocapture %7, i32* nocapture %8, i32** nocapture %9, i32** nocapture %10, i32** nocapture %11, i32* nocapture %12, i32** nocapture %13, i32** nocapture %14, double* nocapture %15) {
%17 = alloca %struct.stat
%18 = bitcast %struct.stat* %17 to i8*
%19 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str, i64 0, i64 0))
store double 4.000000e+01, double* %2
store double 4.000000e+01, double* %3
store double 1.000000e-01, double* %15
%20 = load double, double* %2
%21 = fdiv double %20, 1.000000e-01
%22 = fadd double %21, 1.000000e-03
%23 = fptosi double %22 to i32
%24 = add i32 %23, 1
%25 = load double, double* %3
%26 = fdiv double %25, 1.000000e-01
%27 = fadd double %26, 1.000000e-03
%28 = fptosi double %27 to i32
%29 = add nsw i32 %28, 1
%30 = mul nsw i32 %29, %24
store i32 %30, i32* %1
%31 = shl i32 %30, 4
%32 = tail call i64 @malloc(i32 %31)
%33 = inttoptr i64 %32 to double*
store double* %33, double** %4
%34 = icmp slt i32 %23, 0
br i1 %34, label %149, label %35
35: ; preds = %16
%36 = icmp slt i32 %28, 0
%37 = zext i32 %29 to i64
%38 = add nsw i64 %37, -1
%39 = shl i32 %28, 1
%40 = add i32 %39, 2
%41 = getelementptr double, double* %33, i64 1
%42 = getelementptr double, double* %15, i64 1
%43 = shl nuw nsw i64 %37, 1
%44 = getelementptr double, double* %33, i64 %43
%45 = icmp ult i32 %29, 2
%46 = trunc i64 %38 to i32
%47 = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %46, i32 2)
%48 = extractvalue { i32, i1 } %47, 0
%49 = extractvalue { i32, i1 } %47, 1
%50 = icmp ugt i64 %38, 4294967295
%51 = trunc i64 %38 to i32
%52 = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %51, i32 2)
%53 = extractvalue { i32, i1 } %52, 0
%54 = extractvalue { i32, i1 } %52, 1
%55 = icmp ugt i64 %38, 4294967295
%56 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %38, i64 16)
%57 = extractvalue { i64, i1 } %56, 0
%58 = extractvalue { i64, i1 } %56, 1
%59 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %38, i64 16)
%60 = extractvalue { i64, i1 } %59, 0
%61 = extractvalue { i64, i1 } %59, 1
%62 = and i64 %37, 4294967294
%63 = getelementptr inbounds double, double* %33, i64 -1
%64 = icmp eq i64 %62, %37
br label %65
65: ; preds = %35, %146
%66 = phi i32 [ 0, %35 ], [ %147, %146 ]
%67 = mul i32 %40, %66
%68 = sext i32 %67 to i64
%69 = getelementptr double, double* %33, i64 %68
%70 = getelementptr double, double* %44, i64 %68
%71 = mul i32 %40, %66
%72 = or i32 %71, 1
%73 = sext i32 %71 to i64
%74 = getelementptr double, double* %33, i64 %73
%75 = bitcast double* %74 to i8*
%76 = getelementptr double, double* %41, i64 %73
%77 = bitcast double* %76 to i8*
br i1 %36, label %146, label %78
78: ; preds = %65
%79 = mul nsw i32 %66, %29
%80 = sitofp i32 %66 to double
br i1 %45, label %127, label %81
81: ; preds = %78
%82 = add i32 %71, %48
%83 = icmp slt i32 %82, %71
%84 = or i1 %83, %49
%85 = or i1 %84, %50
%86 = add i32 %72, %53
%87 = icmp slt i32 %86, %72
%88 = or i1 %87, %54
%89 = or i1 %88, %55
%90 = getelementptr i8, i8* %75, i64 %57
%91 = icmp ult i8* %90, %75
%92 = or i1 %91, %58
%93 = getelementptr i8, i8* %77, i64 %60
%94 = icmp ult i8* %93, %77
%95 = or i1 %94, %61
%96 = or i1 %85, %89
%97 = or i1 %96, %92
%98 = or i1 %97, %95
br i1 %98, label %127, label %99
99: ; preds = %81
%100 = icmp ugt double* %70, %15
%101 = icmp ult double* %69, %42
%102 = and i1 %100, %101
br i1 %102, label %127, label %103
103: ; preds = %99, %103
%104 = phi i64 [ %124, %103 ], [ 0, %99 ]
%105 = trunc i64 %104 to i32
%106 = or i32 %105, 1
%107 = insertelement <2 x i32> poison, i32 %105, i64 0
%108 = insertelement <2 x i32> %107, i32 %106, i64 1
%109 = add nsw i32 %79, %105
%110 = load double, double* %15
%111 = fmul double %110, %80
%112 = insertelement <2 x double> poison, double %111, i64 0
%113 = shufflevector <2 x double> %112, <2 x double> poison, <2 x i32> zeroinitializer
%114 = shl nsw i32 %109, 1
%115 = sitofp <2 x i32> %108 to <2 x double>
%116 = insertelement <2 x double> poison, double %110, i64 0
%117 = shufflevector <2 x double> %116, <2 x double> poison, <2 x i32> zeroinitializer
%118 = fmul <2 x double> %117, %115
%119 = or i32 %114, 1
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds double, double* %63, i64 %120
%122 = bitcast double* %121 to <4 x double>*
%123 = shufflevector <2 x double> %113, <2 x double> %118, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %123, <4 x double>* %122
%124 = add nuw i64 %104, 2
%125 = icmp eq i64 %124, %62
br i1 %125, label %126, label %103
126: ; preds = %103
br i1 %64, label %146, label %127
127: ; preds = %99, %81, %78, %126
%128 = phi i64 [ 0, %99 ], [ 0, %81 ], [ 0, %78 ], [ %62, %126 ]
br label %129
129: ; preds = %127, %129
%130 = phi i64 [ %144, %129 ], [ %128, %127 ]
%131 = trunc i64 %130 to i32
%132 = add nsw i32 %79, %131
%133 = load double, double* %15
%134 = fmul double %133, %80
%135 = shl nsw i32 %132, 1
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds double, double* %33, i64 %136
store double %134, double* %137
%138 = sitofp i32 %131 to double
%139 = load double, double* %15
%140 = fmul double %139, %138
%141 = or i32 %135, 1
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds double, double* %33, i64 %142
store double %140, double* %143
%144 = add nuw nsw i64 %130, 1
%145 = icmp eq i64 %144, %37
br i1 %145, label %146, label %129
146: ; preds = %129, %126, %65
%147 = add nuw i32 %66, 1
%148 = icmp eq i32 %66, %23
br i1 %148, label %149, label %65
149: ; preds = %146, %16
%150 = sdiv i32 %23, 2
%151 = sdiv i32 %28, 2
%152 = mul nsw i32 %151, %150
store i32 %152, i32* %5
%153 = mul i32 %152, 36
%154 = tail call i64 @malloc(i32 %153)
%155 = inttoptr i64 %154 to i32*
store i32* %155, i32** %6
%156 = icmp sgt i32 %23, 1
br i1 %156, label %157, label %171
157: ; preds = %149
%158 = icmp sgt i32 %28, 1
%159 = zext i32 %29 to i64
%160 = sext i32 %151 to i64
%161 = zext i32 %150 to i64
%162 = zext i32 %151 to i64
br label %163
163: ; preds = %157, %197
%164 = phi i64 [ 0, %157 ], [ %198, %197 ]
br i1 %158, label %165, label %197
165: ; preds = %163
%166 = mul nsw i64 %164, %160
%167 = shl nuw nsw i64 %164, 1
%168 = mul i64 %167, %159
%169 = add nuw nsw i64 %167, 2
%170 = mul i64 %169, %159
br label %174
171: ; preds = %197, %149
%172 = load i32, i32* %5
%173 = icmp sgt i32 %172, 0
br i1 %173, label %200, label %235
174: ; preds = %165, %174
%175 = phi i64 [ 0, %165 ], [ %195, %174 ]
%176 = add nsw i64 %175, %166
%177 = shl nuw nsw i64 %175, 1
%178 = add i64 %177, %168
%179 = mul nsw i64 %176, 9
%180 = getelementptr inbounds i32, i32* %155, i64 %179
%181 = trunc i64 %178 to i32
store i32 %181, i32* %180
%182 = add i64 %177, %170
%183 = add nsw i64 %179, 1
%184 = getelementptr inbounds i32, i32* %155, i64 %183
%185 = trunc i64 %182 to i32
store i32 %185, i32* %184
%186 = add nuw nsw i64 %177, 2
%187 = add i64 %186, %170
%188 = add nsw i64 %179, 2
%189 = getelementptr inbounds i32, i32* %155, i64 %188
%190 = trunc i64 %187 to i32
store i32 %190, i32* %189
%191 = add i64 %186, %168
%192 = add nsw i64 %179, 3
%193 = getelementptr inbounds i32, i32* %155, i64 %192
%194 = trunc i64 %191 to i32
store i32 %194, i32* %193
%195 = add nuw nsw i64 %175, 1
%196 = icmp eq i64 %195, %162
br i1 %196, label %197, label %174
197: ; preds = %174, %163
%198 = add nuw nsw i64 %164, 1
%199 = icmp eq i64 %198, %161
br i1 %199, label %171, label %163
200: ; preds = %171, %200
%201 = phi i64 [ %231, %200 ], [ 0, %171 ]
%202 = mul nuw nsw i64 %201, 9
%203 = getelementptr inbounds i32, i32* %155, i64 %202
%204 = load i32, i32* %203
%205 = add nuw nsw i64 %202, 1
%206 = getelementptr inbounds i32, i32* %155, i64 %205
%207 = load i32, i32* %206
%208 = add nsw i32 %207, %204
%209 = sdiv i32 %208, 2
%210 = add nuw nsw i64 %202, 4
%211 = getelementptr inbounds i32, i32* %155, i64 %210
store i32 %209, i32* %211
%212 = add nsw i32 %207, 1
%213 = add nuw nsw i64 %202, 5
%214 = getelementptr inbounds i32, i32* %155, i64 %213
store i32 %212, i32* %214
%215 = add nuw nsw i64 %202, 2
%216 = getelementptr inbounds i32, i32* %155, i64 %215
%217 = load i32, i32* %216
%218 = add nuw nsw i64 %202, 3
%219 = getelementptr inbounds i32, i32* %155, i64 %218
%220 = load i32, i32* %219
%221 = add nsw i32 %220, %217
%222 = sdiv i32 %221, 2
%223 = add nuw nsw i64 %202, 6
%224 = getelementptr inbounds i32, i32* %155, i64 %223
store i32 %222, i32* %224
%225 = add nsw i32 %220, -1
%226 = add nuw nsw i64 %202, 7
%227 = getelementptr inbounds i32, i32* %155, i64 %226
store i32 %225, i32* %227
%228 = add nsw i32 %209, 1
%229 = add nuw nsw i64 %202, 8
%230 = getelementptr inbounds i32, i32* %155, i64 %229
store i32 %228, i32* %230
%231 = add nuw nsw i64 %201, 1
%232 = load i32, i32* %5
%233 = sext i32 %232 to i64
%234 = icmp slt i64 %231, %233
br i1 %234, label %200, label %235
235: ; preds = %200, %171
%236 = load i32, i32* %1
%237 = shl i32 %236, 3
%238 = tail call i64 @malloc(i32 %237)
%239 = inttoptr i64 %238 to i32*
store i32* %239, i32** %9
%240 = load i32, i32* %1
%241 = icmp sgt i32 %240, 0
br i1 %241, label %242, label %250
242: ; preds = %235, %242
%243 = phi i64 [ %245, %242 ], [ 0, %235 ]
%244 = getelementptr inbounds i32, i32* %239, i64 %243
store i32 -1, i32* %244
%245 = add nuw nsw i64 %243, 1
%246 = load i32, i32* %1
%247 = shl nsw i32 %246, 1
%248 = sext i32 %247 to i64
%249 = icmp slt i64 %245, %248
br i1 %249, label %242, label %250
250: ; preds = %242, %235
store i32 0, i32* %8
store i32 0, i32* %12
%251 = load i32, i32* %1
%252 = icmp sgt i32 %251, 0
br i1 %252, label %253, label %328
253: ; preds = %250
%254 = load double*, double** %4
br label %259
255: ; preds = %289
%256 = icmp sgt i32 %290, 0
br i1 %256, label %257, label %328
257: ; preds = %255
%258 = load double*, double** %4
br label %294
259: ; preds = %253, %289
%260 = phi i32 [ %251, %253 ], [ %290, %289 ]
%261 = phi i64 [ 0, %253 ], [ %291, %289 ]
%262 = shl nuw nsw i64 %261, 1
%263 = getelementptr inbounds double, double* %254, i64 %262
%264 = load double, double* %263
%265 = fcmp ogt double %264, 1.000000e-03
br i1 %265, label %266, label %289
266: ; preds = %259
%267 = load double, double* %2
%268 = fadd double %267, -1.000000e-03
%269 = fcmp olt double %264, %268
br i1 %269, label %270, label %289
270: ; preds = %266
%271 = or i64 %262, 1
%272 = getelementptr inbounds double, double* %254, i64 %271
%273 = load double, double* %272
%274 = load double, double* %3
%275 = fadd double %274, -1.000000e-03
%276 = fcmp ogt double %273, %275
br i1 %276, label %277, label %289
277: ; preds = %270
%278 = load i32, i32* %8
%279 = add nsw i32 %278, 1
store i32 %279, i32* %8
%280 = getelementptr inbounds i32, i32* %239, i64 %262
store i32 %278, i32* %280
%281 = load i32, i32* %12
%282 = add nsw i32 %281, 1
store i32 %282, i32* %12
%283 = load i32, i32* %8
%284 = add nsw i32 %283, 1
store i32 %284, i32* %8
%285 = getelementptr inbounds i32, i32* %239, i64 %271
store i32 %283, i32* %285
%286 = load i32, i32* %12
%287 = add nsw i32 %286, 1
store i32 %287, i32* %12
%288 = load i32, i32* %1
br label %289
289: ; preds = %259, %266, %270, %277
%290 = phi i32 [ %260, %259 ], [ %260, %266 ], [ %260, %270 ], [ %288, %277 ]
%291 = add nuw nsw i64 %261, 1
%292 = sext i32 %290 to i64
%293 = icmp slt i64 %291, %292
br i1 %293, label %259, label %255
294: ; preds = %257, %323
%295 = phi i64 [ 0, %257 ], [ %324, %323 ]
%296 = shl nuw nsw i64 %295, 1
%297 = getelementptr inbounds double, double* %258, i64 %296
%298 = load double, double* %297
%299 = fcmp ogt double %298, 1.000000e-03
br i1 %299, label %300, label %323
300: ; preds = %294
%301 = load double, double* %2
%302 = fadd double %301, -1.000000e-03
%303 = fcmp olt double %298, %302
br i1 %303, label %304, label %323
304: ; preds = %300
%305 = or i64 %296, 1
%306 = getelementptr inbounds double, double* %258, i64 %305
%307 = load double, double* %306
%308 = fcmp ogt double %307, 1.000000e-03
br i1 %308, label %309, label %323
309: ; preds = %304
%310 = getelementptr inbounds i32, i32* %239, i64 %296
%311 = load i32, i32* %310
%312 = icmp eq i32 %311, -1
br i1 %312, label %313, label %316
313: ; preds = %309
%314 = load i32, i32* %8
%315 = add nsw i32 %314, 1
store i32 %315, i32* %8
store i32 %314, i32* %310
br label %316
316: ; preds = %313, %309
%317 = getelementptr inbounds i32, i32* %239, i64 %305
%318 = load i32, i32* %317
%319 = icmp eq i32 %318, -1
br i1 %319, label %320, label %323
320: ; preds = %316
%321 = load i32, i32* %8
%322 = add nsw i32 %321, 1
store i32 %322, i32* %8
store i32 %321, i32* %317
br label %323
323: ; preds = %294, %300, %304, %320, %316
%324 = add nuw nsw i64 %295, 1
%325 = load i32, i32* %1
%326 = sext i32 %325 to i64
%327 = icmp slt i64 %324, %326
br i1 %327, label %294, label %328
328: ; preds = %323, %250, %255
%329 = icmp eq i32 %0, 1
br i1 %329, label %332, label %330
330: ; preds = %328
%331 = load i32, i32* %8
br label %378
332: ; preds = %328
%333 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str.35, i64 0, i64 0))
%334 = load i32, i32* %1
%335 = icmp sgt i32 %334, 0
br i1 %335, label %336, label %374
336: ; preds = %332
%337 = load i32*, i32** %9
br label %338
338: ; preds = %336, %369
%339 = phi i64 [ 0, %336 ], [ %370, %369 ]
%340 = shl nuw nsw i64 %339, 1
%341 = getelementptr inbounds i32, i32* %337, i64 %340
%342 = load i32, i32* %341
%343 = load i32, i32* %12
%344 = icmp slt i32 %342, %343
%345 = icmp sgt i32 %342, -1
%346 = and i1 %345, %344
br i1 %346, label %347, label %349
347: ; preds = %338
%348 = sub nuw nsw i32 -2, %342
br label %352
349: ; preds = %338
br i1 %344, label %354, label %350
350: ; preds = %349
%351 = sub nsw i32 %342, %343
br label %352
352: ; preds = %350, %347
%353 = phi i32 [ %348, %347 ], [ %351, %350 ]
store i32 %353, i32* %341
br label %354
354: ; preds = %352, %349
%355 = or i64 %340, 1
%356 = getelementptr inbounds i32, i32* %337, i64 %355
%357 = load i32, i32* %356
%358 = load i32, i32* %12
%359 = icmp slt i32 %357, %358
%360 = icmp sgt i32 %357, -1
%361 = and i1 %360, %359
br i1 %361, label %365, label %362
362: ; preds = %354
br i1 %359, label %369, label %363
363: ; preds = %362
%364 = sub nsw i32 %357, %358
br label %367
365: ; preds = %354
%366 = sub nuw nsw i32 -2, %357
br label %367
367: ; preds = %363, %365
%368 = phi i32 [ %366, %365 ], [ %364, %363 ]
store i32 %368, i32* %356
br label %369
369: ; preds = %367, %362
%370 = add nuw nsw i64 %339, 1
%371 = load i32, i32* %1
%372 = sext i32 %371 to i64
%373 = icmp slt i64 %370, %372
br i1 %373, label %338, label %374
374: ; preds = %369, %332
%375 = load i32, i32* %12
%376 = load i32, i32* %8
%377 = sub nsw i32 %376, %375
store i32 %377, i32* %8
br label %378
378: ; preds = %330, %374
%379 = phi i32 [ %331, %330 ], [ %377, %374 ]
%380 = sdiv i32 %379, 2
%381 = shl i32 %380, 2
%382 = tail call i64 @malloc(i32 %381)
%383 = inttoptr i64 %382 to i32*
store i32* %383, i32** %10
%384 = load i32, i32* %8
%385 = sdiv i32 %384, 2
%386 = shl i32 %385, 2
%387 = tail call i64 @malloc(i32 %386)
%388 = inttoptr i64 %387 to i32*
store i32* %388, i32** %11
%389 = call i64 @stat(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0), %struct.stat* %17)
%390 = icmp eq i64 %389, 0
br i1 %390, label %391, label %396
391: ; preds = %378
%392 = getelementptr inbounds %struct.stat, %struct.stat* %17, i64 0, i32 0
%393 = load i32, i32* %392
%394 = call i32 @S_ISDIR(i32 %393)
%395 = icmp eq i32 %394, 0
br i1 %395, label %396, label %399
396: ; preds = %391, %378
%397 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @str.34, i64 0, i64 0))
%398 = call i32 @mkdir(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0), i32 511)
br label %399
399: ; preds = %396, %391
%400 = call i32* @fopen(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
%401 = load i32, i32* %1
%402 = icmp sgt i32 %401, 0
br i1 %402, label %403, label %435
403: ; preds = %399, %429
%404 = phi i32 [ %430, %429 ], [ %401, %399 ]
%405 = phi i64 [ %432, %429 ], [ 0, %399 ]
%406 = phi i32 [ %431, %429 ], [ 0, %399 ]
%407 = load i32*, i32** %9
%408 = shl nuw nsw i64 %405, 1
%409 = getelementptr inbounds i32, i32* %407, i64 %408
%410 = load i32, i32* %409
%411 = icmp sgt i32 %410, -1
br i1 %411, label %412, label %429
412: ; preds = %403
%413 = load i32*, i32** %10
%414 = sext i32 %406 to i64
%415 = getelementptr inbounds i32, i32* %413, i64 %414
store i32 %410, i32* %415
%416 = or i64 %408, 1
%417 = getelementptr inbounds i32, i32* %407, i64 %416
%418 = load i32, i32* %417
%419 = load i32*, i32** %11
%420 = add nsw i32 %406, 1
%421 = getelementptr inbounds i32, i32* %419, i64 %414
store i32 %418, i32* %421
%422 = load double*, double** %4
%423 = getelementptr inbounds double, double* %422, i64 %408
%424 = load double, double* %423
%425 = getelementptr inbounds double, double* %422, i64 %416
%426 = load double, double* %425
%427 = call i32 (i32*, i8*, ...) @fprintf(i32* %400, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), double %424, double %426)
%428 = load i32, i32* %1
br label %429
429: ; preds = %403, %412
%430 = phi i32 [ %428, %412 ], [ %404, %403 ]
%431 = phi i32 [ %420, %412 ], [ %406, %403 ]
%432 = add nuw nsw i64 %405, 1
%433 = sext i32 %430 to i64
%434 = icmp slt i64 %432, %433
br i1 %434, label %403, label %435
435: ; preds = %429, %399
%436 = call i32 @fclose(i32* %400)
%437 = load double, double* %2
%438 = load double, double* %3
%439 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.7, i64 0, i64 0), double %437, double %438)
%440 = load i32, i32* %8
%441 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.8, i64 0, i64 0), i32 %440)
%442 = load i32, i32* %1
%443 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.9, i64 0, i64 0), i32 %442)
%444 = load i32, i32* %5
%445 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.10, i64 0, i64 0), i32 %444)
%446 = load i32, i32* %12
%447 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.11, i64 0, i64 0), i32 %446)
%448 = load i32, i32* %12
%449 = sdiv i32 %448, 2
%450 = shl i32 %449, 2
%451 = call i64 @malloc(i32 %450)
%452 = inttoptr i64 %451 to i32*
store i32* %452, i32** %13
%453 = load i32, i32* %12
%454 = sdiv i32 %453, 2
%455 = shl i32 %454, 2
%456 = call i64 @malloc(i32 %455)
%457 = inttoptr i64 %456 to i32*
store i32* %457, i32** %14
%458 = icmp eq i32 %0, 0
br i1 %458, label %459, label %501
459: ; preds = %435
%460 = load i32, i32* %1
%461 = icmp sgt i32 %460, 0
br i1 %461, label %462, label %546
462: ; preds = %459
%463 = load double*, double** %4
br label %464
464: ; preds = %462, %495
%465 = phi i32 [ %460, %462 ], [ %496, %495 ]
%466 = phi i64 [ 0, %462 ], [ %498, %495 ]
%467 = phi i32 [ 0, %462 ], [ %497, %495 ]
%468 = shl nuw nsw i64 %466, 1
%469 = getelementptr inbounds double, double* %463, i64 %468
%470 = load double, double* %469
%471 = fcmp ogt double %470, 1.000000e-03
br i1 %471, label %472, label %495
472: ; preds = %464
%473 = load double, double* %2
%474 = fadd double %473, -1.000000e-03
%475 = fcmp olt double %470, %474
br i1 %475, label %476, label %495
476: ; preds = %472
%477 = or i64 %468, 1
%478 = getelementptr inbounds double, double* %463, i64 %477
%479 = load double, double* %478
%480 = load double, double* %3
%481 = fadd double %480, -1.000000e-03
%482 = fcmp ogt double %479, %481
br i1 %482, label %483, label %495
483: ; preds = %476
%484 = load i32*, i32** %9
%485 = getelementptr inbounds i32, i32* %484, i64 %468
%486 = load i32, i32* %485
%487 = load i32*, i32** %13
%488 = sext i32 %467 to i64
%489 = getelementptr inbounds i32, i32* %487, i64 %488
store i32 %486, i32* %489
%490 = getelementptr inbounds i32, i32* %484, i64 %477
%491 = load i32, i32* %490
%492 = add nsw i32 %467, 1
%493 = getelementptr inbounds i32, i32* %457, i64 %488
store i32 %491, i32* %493
%494 = load i32, i32* %1
br label %495
495: ; preds = %464, %472, %476, %483
%496 = phi i32 [ %494, %483 ], [ %465, %476 ], [ %465, %472 ], [ %465, %464 ]
%497 = phi i32 [ %492, %483 ], [ %467, %476 ], [ %467, %472 ], [ %467, %464 ]
%498 = add nuw nsw i64 %466, 1
%499 = sext i32 %496 to i64
%500 = icmp slt i64 %498, %499
br i1 %500, label %464, label %546
501: ; preds = %435
br i1 %329, label %502, label %546
502: ; preds = %501
%503 = load i32, i32* %1
%504 = icmp sgt i32 %503, 0
br i1 %504, label %505, label %546
505: ; preds = %502
%506 = load double*, double** %4
br label %507
507: ; preds = %505, %540
%508 = phi i32 [ %503, %505 ], [ %541, %540 ]
%509 = phi i64 [ 0, %505 ], [ %543, %540 ]
%510 = phi i32 [ 0, %505 ], [ %542, %540 ]
%511 = shl nuw nsw i64 %509, 1
%512 = getelementptr inbounds double, double* %506, i64 %511
%513 = load double, double* %512
%514 = fcmp ogt double %513, 1.000000e-03
br i1 %514, label %515, label %540
515: ; preds = %507
%516 = load double, double* %2
%517 = fadd double %516, -1.000000e-03
%518 = fcmp olt double %513, %517
br i1 %518, label %519, label %540
519: ; preds = %515
%520 = or i64 %511, 1
%521 = getelementptr inbounds double, double* %506, i64 %520
%522 = load double, double* %521
%523 = load double, double* %3
%524 = fadd double %523, -1.000000e-03
%525 = fcmp ogt double %522, %524
br i1 %525, label %526, label %540
526: ; preds = %519
%527 = load i32*, i32** %9
%528 = getelementptr inbounds i32, i32* %527, i64 %511
%529 = load i32, i32* %528
%530 = sub i32 -2, %529
%531 = load i32*, i32** %13
%532 = sext i32 %510 to i64
%533 = getelementptr inbounds i32, i32* %531, i64 %532
store i32 %530, i32* %533
%534 = getelementptr inbounds i32, i32* %527, i64 %520
%535 = load i32, i32* %534
%536 = sub i32 -2, %535
%537 = add nsw i32 %510, 1
%538 = getelementptr inbounds i32, i32* %457, i64 %532
store i32 %536, i32* %538
%539 = load i32, i32* %1
br label %540
540: ; preds = %507, %515, %519, %526
%541 = phi i32 [ %539, %526 ], [ %508, %519 ], [ %508, %515 ], [ %508, %507 ]
%542 = phi i32 [ %537, %526 ], [ %510, %519 ], [ %510, %515 ], [ %510, %507 ]
%543 = add nuw nsw i64 %509, 1
%544 = sext i32 %541 to i64
%545 = icmp slt i64 %543, %544
br i1 %545, label %507, label %546
546: ; preds = %540, %495, %502, %459, %501
%547 = load i32, i32* %5
%548 = shl i32 %547, 2
%549 = call i64 @malloc(i32 %548)
%550 = inttoptr i64 %549 to i32*
store i32* %550, i32** %7
%551 = load i32, i32* %5
%552 = icmp sgt i32 %551, 0
br i1 %552, label %553, label %587
553: ; preds = %546
%554 = load i32*, i32** %6
%555 = load double*, double** %4
%556 = load double, double* %3
%557 = fadd double %556, -1.000000e-03
br label %558
558: ; preds = %553, %580
%559 = phi i64 [ 0, %553 ], [ %583, %580 ]
%560 = mul nuw nsw i64 %559, 9
%561 = add nuw nsw i64 %560, 6
%562 = getelementptr inbounds i32, i32* %554, i64 %561
%563 = load i32, i32* %562
%564 = shl nsw i32 %563, 1
%565 = or i32 %564, 1
%566 = sext i32 %565 to i64
%567 = getelementptr inbounds double, double* %555, i64 %566
%568 = load double, double* %567
%569 = fcmp ogt double %568, %557
br i1 %569, label %570, label %579
570: ; preds = %558
%571 = sext i32 %564 to i64
%572 = getelementptr inbounds double, double* %555, i64 %571
%573 = load double, double* %572
%574 = fcmp ogt double %573, 1.000000e-03
br i1 %574, label %575, label %579
575: ; preds = %570
%576 = load double, double* %2
%577 = fadd double %576, -1.000000e-03
%578 = fcmp olt double %573, %577
br i1 %578, label %580, label %579
579: ; preds = %575, %570, %558
br label %580
580: ; preds = %575, %579
%581 = phi i32 [ 1, %579 ], [ 0, %575 ]
%582 = getelementptr inbounds i32, i32* %550, i64 %559
store i32 %581, i32* %582
%583 = add nuw nsw i64 %559, 1
%584 = load i32, i32* %5
%585 = sext i32 %584 to i64
%586 = icmp slt i64 %583, %585
br i1 %586, label %558, label %587
587: ; preds = %580, %546
%588 = call i32* @fopen(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
%589 = call i64 @fwrite(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.13, i64 0, i64 0), i64 16, i64 1, i32* %588)
%590 = load i32, i32* %1
%591 = call i32 (i32*, i8*, ...) @fprintf(i32* %588, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i64 0, i64 0), i32 %590)
%592 = call i64 @fwrite(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.15, i64 0, i64 0), i64 19, i64 1, i32* %588)
%593 = load i32, i32* %5
%594 = call i32 (i32*, i8*, ...) @fprintf(i32* %588, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i64 0, i64 0), i32 %593)
%595 = call i64 @fwrite(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.16, i64 0, i64 0), i64 29, i64 1, i32* %588)
%596 = load i32, i32* %8
%597 = call i32 (i32*, i8*, ...) @fprintf(i32* %588, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i64 0, i64 0), i32 %596)
%598 = call i64 @fwrite(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.17, i64 0, i64 0), i64 37, i64 1, i32* %588)
%599 = load i32, i32* %12
%600 = call i32 (i32*, i8*, ...) @fprintf(i32* %588, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i64 0, i64 0), i32 %599)
%601 = call i64 @fwrite(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.18, i64 0, i64 0), i64 14, i64 1, i32* %588)
%602 = load double, double* %2
%603 = load double, double* %3
%604 = call i32 (i32*, i8*, ...) @fprintf(i32* %588, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.19, i64 0, i64 0), double %602, double %603)
%605 = call i64 @fwrite(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.20, i64 0, i64 0), i64 10, i64 1, i32* %588)
%606 = load double, double* %15
%607 = call i32 (i32*, i8*, ...) @fprintf(i32* %588, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.21, i64 0, i64 0), double %606)
%608 = call i64 @fwrite(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.22, i64 0, i64 0), i64 24, i64 1, i32* %588)
%609 = call i32 (i32*, i8*, ...) @fprintf(i32* %588, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.23, i64 0, i64 0), i32 %24, i32 %29)
%610 = call i64 @fwrite(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.24, i64 0, i64 0), i64 27, i64 1, i32* %588)
%611 = call i32 (i32*, i8*, ...) @fprintf(i32* %588, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.23, i64 0, i64 0), i32 %150, i32 %151)
%612 = call i32 @fclose(i32* %588)
%613 = call i32* @fopen(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.25, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
%614 = load i32, i32* %5
%615 = icmp sgt i32 %614, 0
br i1 %615, label %616, label %668
616: ; preds = %587, %616
%617 = phi i64 [ %664, %616 ], [ 0, %587 ]
%618 = mul nuw nsw i64 %617, 9
%619 = load i32*, i32** %6
%620 = getelementptr inbounds i32, i32* %619, i64 %618
%621 = load i32, i32* %620
%622 = call i32 (i32*, i8*, ...) @fprintf(i32* %613, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.26, i64 0, i64 0), i32 %621)
%623 = load i32*, i32** %6
%624 = add nuw nsw i64 %618, 1
%625 = getelementptr inbounds i32, i32* %623, i64 %624
%626 = load i32, i32* %625
%627 = call i32 (i32*, i8*, ...) @fprintf(i32* %613, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.26, i64 0, i64 0), i32 %626)
%628 = load i32*, i32** %6
%629 = add nuw nsw i64 %618, 2
%630 = getelementptr inbounds i32, i32* %628, i64 %629
%631 = load i32, i32* %630
%632 = call i32 (i32*, i8*, ...) @fprintf(i32* %613, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.26, i64 0, i64 0), i32 %631)
%633 = load i32*, i32** %6
%634 = add nuw nsw i64 %618, 3
%635 = getelementptr inbounds i32, i32* %633, i64 %634
%636 = load i32, i32* %635
%637 = call i32 (i32*, i8*, ...) @fprintf(i32* %613, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.26, i64 0, i64 0), i32 %636)
%638 = load i32*, i32** %6
%639 = add nuw nsw i64 %618, 4
%640 = getelementptr inbounds i32, i32* %638, i64 %639
%641 = load i32, i32* %640
%642 = call i32 (i32*, i8*, ...) @fprintf(i32* %613, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.26, i64 0, i64 0), i32 %641)
%643 = load i32*, i32** %6
%644 = add nuw nsw i64 %618, 5
%645 = getelementptr inbounds i32, i32* %643, i64 %644
%646 = load i32, i32* %645
%647 = call i32 (i32*, i8*, ...) @fprintf(i32* %613, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.26, i64 0, i64 0), i32 %646)
%648 = load i32*, i32** %6
%649 = add nuw nsw i64 %618, 6
%650 = getelementptr inbounds i32, i32* %648, i64 %649
%651 = load i32, i32* %650
%652 = call i32 (i32*, i8*, ...) @fprintf(i32* %613, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.26, i64 0, i64 0), i32 %651)
%653 = load i32*, i32** %6
%654 = add nuw nsw i64 %618, 7
%655 = getelementptr inbounds i32, i32* %653, i64 %654
%656 = load i32, i32* %655
%657 = call i32 (i32*, i8*, ...) @fprintf(i32* %613, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.26, i64 0, i64 0), i32 %656)
%658 = load i32*, i32** %6
%659 = add nuw nsw i64 %618, 8
%660 = getelementptr inbounds i32, i32* %658, i64 %659
%661 = load i32, i32* %660
%662 = call i32 (i32*, i8*, ...) @fprintf(i32* %613, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.26, i64 0, i64 0), i32 %661)
%663 = call i32 @fputc(i32 10, i32* %613)
%664 = add nuw nsw i64 %617, 1
%665 = load i32, i32* %5
%666 = sext i32 %665 to i64
%667 = icmp slt i64 %664, %666
br i1 %667, label %616, label %668
668: ; preds = %616, %587
%669 = call i32 @fclose(i32* %613)
%670 = call i32* @fopen(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.28, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
%671 = load i32, i32* %5
%672 = icmp sgt i32 %671, 0
br i1 %672, label %673, label %683
673: ; preds = %668, %673
%674 = phi i64 [ %679, %673 ], [ 0, %668 ]
%675 = load i32*, i32** %7
%676 = getelementptr inbounds i32, i32* %675, i64 %674
%677 = load i32, i32* %676
%678 = call i32 (i32*, i8*, ...) @fprintf(i32* %670, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i64 0, i64 0), i32 %677)
%679 = add nuw nsw i64 %674, 1
%680 = load i32, i32* %5
%681 = sext i32 %680 to i64
%682 = icmp slt i64 %679, %681
br i1 %682, label %673, label %683
683: ; preds = %673, %668
%684 = call i32 @fclose(i32* %670)
%685 = call i32* @fopen(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.29, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
%686 = load i32, i32* %1
%687 = icmp sgt i32 %686, 0
br i1 %687, label %688, label %700
688: ; preds = %683, %688
%689 = phi i64 [ %693, %688 ], [ 0, %683 ]
%690 = load i32*, i32** %9
%691 = getelementptr inbounds i32, i32* %690, i64 %689
%692 = load i32, i32* %691
%693 = add nuw nsw i64 %689, 1
%694 = getelementptr inbounds i32, i32* %690, i64 %693
%695 = load i32, i32* %694
%696 = call i32 (i32*, i8*, ...) @fprintf(i32* %685, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.30, i64 0, i64 0), i32 %692, i32 %695)
%697 = load i32, i32* %1
%698 = sext i32 %697 to i64
%699 = icmp slt i64 %693, %698
br i1 %699, label %688, label %700
700: ; preds = %688, %683
%701 = call i32 @fclose(i32* %685)
%702 = call i32* @fopen(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.31, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
%703 = load i32, i32* %12
%704 = icmp sgt i32 %703, 1
br i1 %704, label %705, label %719
705: ; preds = %700, %705
%706 = phi i64 [ %714, %705 ], [ 0, %700 ]
%707 = load i32*, i32** %13
%708 = getelementptr inbounds i32, i32* %707, i64 %706
%709 = load i32, i32* %708
%710 = load i32*, i32** %14
%711 = getelementptr inbounds i32, i32* %710, i64 %706
%712 = load i32, i32* %711
%713 = call i32 (i32*, i8*, ...) @fprintf(i32* %702, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.30, i64 0, i64 0), i32 %709, i32 %712)
%714 = add nuw nsw i64 %706, 1
%715 = load i32, i32* %12
%716 = sdiv i32 %715, 2
%717 = sext i32 %716 to i64
%718 = icmp slt i64 %714, %717
br i1 %718, label %705, label %719
719: ; preds = %705, %700
%720 = call i32 @fclose(i32* %702)
%721 = call i32* @fopen(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.32, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
%722 = load i32, i32* %8
%723 = icmp sgt i32 %722, 1
br i1 %723, label %724, label %735
724: ; preds = %719, %724
%725 = phi i64 [ %730, %724 ], [ 0, %719 ]
%726 = load i32*, i32** %10
%727 = getelementptr inbounds i32, i32* %726, i64 %725
%728 = load i32, i32* %727
%729 = call i32 (i32*, i8*, ...) @fprintf(i32* %721, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i64 0, i64 0), i32 %728)
%730 = add nuw nsw i64 %725, 1
%731 = load i32, i32* %8
%732 = sdiv i32 %731, 2
%733 = sext i32 %732 to i64
%734 = icmp slt i64 %730, %733
br i1 %734, label %724, label %735
735: ; preds = %724, %719
%736 = call i32 @fclose(i32* %721)
%737 = call i32* @fopen(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.33, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
%738 = load i32, i32* %8
%739 = icmp sgt i32 %738, 1
br i1 %739, label %740, label %751
740: ; preds = %735, %740
%741 = phi i64 [ %746, %740 ], [ 0, %735 ]
%742 = load i32*, i32** %11
%743 = getelementptr inbounds i32, i32* %742, i64 %741
%744 = load i32, i32* %743
%745 = call i32 (i32*, i8*, ...) @fprintf(i32* %737, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i64 0, i64 0), i32 %744)
%746 = add nuw nsw i64 %741, 1
%747 = load i32, i32* %8
%748 = sdiv i32 %747, 2
%749 = sext i32 %748 to i64
%750 = icmp slt i64 %746, %749
br i1 %750, label %740, label %751
751: ; preds = %740, %735
%752 = call i32 @fclose(i32* %737)
ret void
}