#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
scalar_t__ fisCalloc(int, int);
int /*<<< orphan*/ fisError(char *);
int /*<<< orphan*/ *fisOpenFile(char *, char *);
int /*<<< orphan*/ free(double *);
int getArray(char *, double *);
int /*<<< orphan*/ getMfN(char *, int, double *, int, double *);
int /*<<< orphan*/ *getNextLine(char *, int /*<<< orphan*/ *);
scalar_t__ getNumber(char *, int /*<<< orphan*/ *);
int /*<<< orphan*/ getString(char *, int /*<<< orphan*/ *, double *);
double **returnEmptyFismatrix(char *, int *, int *);
int sscanf(char *, char *, char *, ...);
int /*<<< orphan*/ strcmp(char *, char *);
scalar_t__ strlen(char *);
double **returnFismatrix(char *fis_file, int *row_n_p, int *col_n_p) {
  int i, j, k;
  FILE *fp;
  char buf[500];
  char str1[500], str2[500], str3[500], str4[500];
  char fisType[500];
  int in_n, out_n, rule_n;
  int mf_n;
  int now;
  double **fismatrix;
  double *in_mf_n, *out_mf_n;
  fismatrix = returnEmptyFismatrix(fis_file, row_n_p, col_n_p);
  fp = fisOpenFile(fis_file, "r");
  while (1) {
    if (getNextLine(buf, fp) == NULL)
      fisError("Cannot find [System] in FIS file!");
    if (!strcmp(buf, "[System]"))
      break;
  }
  now = 0;
  getString(buf, fp, fismatrix[now++]);
  getString(buf, fp, fismatrix[now++]);
  for (i = 0; i < 500 && fismatrix[1][i] != 0; i++)
    fisType[i] = (int)fismatrix[1][i];
  fisType[i] = 0;
  in_n = (int)getNumber(buf, fp);
  out_n = (int)getNumber(buf, fp);
  fismatrix[now][0] = (double)in_n;
  fismatrix[now][1] = (double)out_n;
  now++;
  in_mf_n = (double *)fisCalloc(in_n, sizeof(double));
  out_mf_n = (double *)fisCalloc(out_n, sizeof(double));
  getMfN(fis_file, in_n, in_mf_n, out_n, out_mf_n);
  for (i = 0; i < in_n; i++)
    fismatrix[now][i] = in_mf_n[i];
  now++;
  for (i = 0; i < out_n; i++)
    fismatrix[now][i] = out_mf_n[i];
  now++;
  rule_n = (int)getNumber(buf, fp);
  fismatrix[now++][0] = (double)rule_n;
  getString(buf, fp, fismatrix[now++]);
  getString(buf, fp, fismatrix[now++]);
  getString(buf, fp, fismatrix[now++]);
  getString(buf, fp, fismatrix[now++]);
  getString(buf, fp, fismatrix[now++]);
  fclose(fp);
  fp = fisOpenFile(fis_file, "r");
  while (1) {
    if (getNextLine(buf, fp) == NULL)
      fisError("Cannot find the first Name in FIS file!");
    if (sscanf(buf, " Name = '%[^']' ", str1) == 1)
      break;
  }
  for (i = 0; i < in_n + out_n; i++) {
    while (1) {
      if (getNextLine(buf, fp) == NULL)
        fisError("Not enough Name in FIS file!");
      if (sscanf(buf, " Name = '%[^']' ", str1) == 1)
        break;
    }
    for (j = 0; j < (int)strlen(str1); j++)
      fismatrix[now][j] = str1[j];
    now++;
  }
  fclose(fp);
  fp = fisOpenFile(fis_file, "r");
  for (i = 0; i < in_n + out_n; i++) {
    while (1) {
      if (getNextLine(buf, fp) == NULL)
        fisError("Not enough Range in FIS file!");
      if (sscanf(buf, " Range = [ %[^]] ", str1) == 1)
        break;
    }
    if (getArray(str1, fismatrix[now++]) != 2)
      fisError("Error in parsing I/O ranges.");
  }
  fclose(fp);
  fp = fisOpenFile(fis_file, "r");
  for (i = 0; i < in_n + out_n; i++) {
    mf_n = i < in_n ? in_mf_n[i] : out_mf_n[i - in_n];
    for (j = 0; j < mf_n; j++) {
      while (1) {
        if (getNextLine(buf, fp) == NULL)
          fisError("Not enough MF Labels in FIS file!");
        if (sscanf(buf, " %[^']'%[^']' : '%[^']' , [ %[^]] ", str1, str2, str3,
                   str4) == 4)
          break;
      }
      for (k = 0; k < (int)strlen(str2); k++)
        fismatrix[now][k] = str2[k];
      now++;
    }
  }
  fclose(fp);
  fp = fisOpenFile(fis_file, "r");
  for (i = 0; i < in_n + out_n; i++) {
    mf_n = i < in_n ? in_mf_n[i] : out_mf_n[i - in_n];
    for (j = 0; j < mf_n; j++) {
      while (1) {
        if (getNextLine(buf, fp) == NULL)
          fisError("Not enough MF types in FIS file!");
        if (sscanf(buf, " %[^']'%[^']' : '%[^']' , [ %[^]] ", str1, str2, str3,
                   str4) == 4)
          break;
      }
      for (k = 0; k < (int)strlen(str3); k++)
        fismatrix[now][k] = str3[k];
      now++;
    }
  }
  fclose(fp);
  fp = fisOpenFile(fis_file, "r");
  for (i = 0; i < in_n + out_n; i++) {
    mf_n = i < in_n ? in_mf_n[i] : out_mf_n[i - in_n];
    for (j = 0; j < mf_n; j++) {
      while (1) {
        if (getNextLine(buf, fp) == NULL)
          fisError("Not enough MF parameters in FIS file!");
        if (sscanf(buf, " %[^']'%[^']' : '%[^']' , [ %[^]] ", str1, str2, str3,
                   str4) == 4) {
          break;
        }
      }
      if (i < in_n) {
        if (getArray(str4, fismatrix[now]) > 4) {
          fisError("Error in parsing input MF parameters.");
        }
      } else {
        if (!strcmp(fisType, "mamdani")) {
          if (getArray(str4, fismatrix[now]) > 4) {
            fisError("Error in parsing output MF parameters.");
          }
        } else {
          int tmp = getArray(str4, fismatrix[now]);
          if (!strcmp(str3, "constant")) {
            if (tmp != 1)
              fisError("Zero-order Sugeno system does not has the right number "
                       "of output MF parameters.");
            else {
              fismatrix[now][in_n] = fismatrix[now][0];
              fismatrix[now][0] = 0;
            }
          } else if (!strcmp(str3, "linear")) {
            if (tmp != in_n + 1)
              fisError("First-order Sugeno system does not has the right "
                       "number of output MF parameters.");
          } else {
            fisError("Unknown output MF type for Sugeno system.");
          }
        }
      }
      now++;
    }
  }
  fclose(fp);
  fp = fisOpenFile(fis_file, "r");
  while (1) {
    if (getNextLine(buf, fp) == NULL)
      fisError("Cannot find [Rules] in FIS file!");
    if (!strcmp(buf, "[Rules]"))
      break;
  }
  for (i = 0; i < rule_n; i++) {
    if (getNextLine(buf, fp) == NULL)
      fisError("Not enough rule list in FIS file!");
    for (j = 0; j < (int)strlen(buf); j++)
      if (buf[j] == ',' || buf[j] == '(' || buf[j] == ')' || buf[j] == ':')
        buf[j] = ' ';
    if (getArray(buf, fismatrix[now++]) != in_n + out_n + 2) {
      fisError("Error in parsing rule list!");
    }
  }
  fclose(fp);
  free(in_mf_n);
  free(out_mf_n);
  return (fismatrix);
}


x86 assembly (clang, -O0):
<returnFismatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0xca0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
call   10f0 <returnEmptyFismatrix@plt>
mov    %rax,-0xc50(%rbp)
mov    -0x8(%rbp),%rdi
lea    0x1ff3(%rip),%rsi
call   1090 <fisOpenFile@plt>
mov    %rax,-0x30(%rbp)
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   10a0 <getNextLine@plt>
cmp    $0x0,%rax
jne    1249 <returnFismatrix+0x69>
lea    0x1dbc(%rip),%rdi
call   1050 <fisError@plt>
lea    -0x230(%rbp),%rdi
lea    0x1dcb(%rip),%rsi
call   10b0 <strcmp@plt>
cmp    $0x0,%eax
jne    126a <returnFismatrix+0x8a>
jmp    126f <returnFismatrix+0x8f>
jmp    1223 <returnFismatrix+0x43>
movl   $0x0,-0xc44(%rbp)
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0xc50(%rbp),%rax
mov    -0xc44(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xc44(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
call   1030 <getString@plt>
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0xc50(%rbp),%rax
mov    -0xc44(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xc44(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
call   1030 <getString@plt>
movl   $0x0,-0x1c(%rbp)
xor    %eax,%eax
cmpl   $0x1f4,-0x1c(%rbp)
mov    %al,-0xc65(%rbp)
jge    131c <returnFismatrix+0x13c>
mov    -0xc50(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0xc65(%rbp)
mov    -0xc65(%rbp),%al
test   $0x1,%al
jne    132f <returnFismatrix+0x14f>
jmp    135e <returnFismatrix+0x17e>
mov    -0xc50(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x1c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
mov    %al,%cl
movslq -0x1c(%rbp),%rax
mov    %cl,-0xc30(%rbp,%rax,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12de <returnFismatrix+0xfe>
movslq -0x1c(%rbp),%rax
movb   $0x0,-0xc30(%rbp,%rax,1)
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   10d0 <getNumber@plt>
mov    %eax,-0xc34(%rbp)
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   10d0 <getNumber@plt>
mov    %eax,-0xc38(%rbp)
cvtsi2sdl -0xc34(%rbp),%xmm0
ff
mov    -0xc50(%rbp),%rax
movslq -0xc44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
cvtsi2sdl -0xc38(%rbp),%xmm0
ff
mov    -0xc50(%rbp),%rax
movslq -0xc44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,0x8(%rax)
mov    -0xc44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc44(%rbp)
mov    -0xc34(%rbp),%edi
mov    $0x8,%esi
call   1060 <fisCalloc@plt>
mov    %rax,-0xc58(%rbp)
mov    -0xc38(%rbp),%edi
mov    $0x8,%esi
call   1060 <fisCalloc@plt>
mov    %rax,-0xc60(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc34(%rbp),%esi
mov    -0xc58(%rbp),%rdx
mov    -0xc38(%rbp),%ecx
mov    -0xc60(%rbp),%r8
call   1100 <getMfN@plt>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc34(%rbp),%eax
jge    1482 <returnFismatrix+0x2a2>
mov    -0xc58(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xc50(%rbp),%rax
movslq -0xc44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    143a <returnFismatrix+0x25a>
mov    -0xc44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc44(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc38(%rbp),%eax
jge    14e0 <returnFismatrix+0x300>
mov    -0xc60(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xc50(%rbp),%rax
movslq -0xc44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1498 <returnFismatrix+0x2b8>
mov    -0xc44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc44(%rbp)
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   10d0 <getNumber@plt>
mov    %eax,-0xc3c(%rbp)
cvtsi2sdl -0xc3c(%rbp),%xmm0
ff
mov    -0xc50(%rbp),%rax
mov    -0xc44(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xc44(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0xc50(%rbp),%rax
mov    -0xc44(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xc44(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
call   1030 <getString@plt>
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0xc50(%rbp),%rax
mov    -0xc44(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xc44(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
call   1030 <getString@plt>
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0xc50(%rbp),%rax
mov    -0xc44(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xc44(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
call   1030 <getString@plt>
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0xc50(%rbp),%rax
mov    -0xc44(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xc44(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
call   1030 <getString@plt>
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0xc50(%rbp),%rax
mov    -0xc44(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xc44(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
call   1030 <getString@plt>
mov    -0x30(%rbp),%rdi
call   1070 <fclose@plt>
mov    -0x8(%rbp),%rdi
lea    0x1bde(%rip),%rsi
call   1090 <fisOpenFile@plt>
mov    %rax,-0x30(%rbp)
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   10a0 <getNextLine@plt>
cmp    $0x0,%rax
jne    165e <returnFismatrix+0x47e>
lea    0x19d2(%rip),%rdi
call   1050 <fisError@plt>
lea    -0x230(%rbp),%rdi
lea    -0x430(%rbp),%rdx
lea    0x19e0(%rip),%rsi
mov    $0x0,%al
call   10c0 <sscanf@plt>
cmp    $0x1,%eax
jne    1688 <returnFismatrix+0x4a8>
jmp    168d <returnFismatrix+0x4ad>
jmp    1638 <returnFismatrix+0x458>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0xc34(%rbp),%ecx
add    -0xc38(%rbp),%ecx
cmp    %ecx,%eax
jge    1788 <returnFismatrix+0x5a8>
jmp    16b0 <returnFismatrix+0x4d0>
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   10a0 <getNextLine@plt>
cmp    $0x0,%rax
jne    16d6 <returnFismatrix+0x4f6>
lea    0x1993(%rip),%rdi
call   1050 <fisError@plt>
lea    -0x230(%rbp),%rdi
lea    -0x430(%rbp),%rdx
lea    0x1968(%rip),%rsi
mov    $0x0,%al
call   10c0 <sscanf@plt>
cmp    $0x1,%eax
jne    1700 <returnFismatrix+0x520>
jmp    1705 <returnFismatrix+0x525>
jmp    16b0 <returnFismatrix+0x4d0>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0xc6c(%rbp)
lea    -0x430(%rbp),%rdi
call   1080 <strlen@plt>
mov    %rax,%rcx
mov    -0xc6c(%rbp),%eax
cmp    %ecx,%eax
jge    176b <returnFismatrix+0x58b>
movslq -0x20(%rbp),%rax
movsbl -0x430(%rbp,%rax,1),%eax
ff
cvtsi2sd %eax,%xmm0
mov    -0xc50(%rbp),%rax
movslq -0xc44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    170c <returnFismatrix+0x52c>
mov    -0xc44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc44(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1694 <returnFismatrix+0x4b4>
mov    -0x30(%rbp),%rdi
call   1070 <fclose@plt>
mov    -0x8(%rbp),%rdi
lea    0x1a71(%rip),%rsi
call   1090 <fisOpenFile@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0xc34(%rbp),%ecx
add    -0xc38(%rbp),%ecx
cmp    %ecx,%eax
jge    1870 <returnFismatrix+0x690>
jmp    17c8 <returnFismatrix+0x5e8>
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   10a0 <getNextLine@plt>
cmp    $0x0,%rax
jne    17ee <returnFismatrix+0x60e>
lea    0x1898(%rip),%rdi
call   1050 <fisError@plt>
lea    -0x230(%rbp),%rdi
lea    -0x430(%rbp),%rdx
lea    0x189c(%rip),%rsi
mov    $0x0,%al
call   10c0 <sscanf@plt>
cmp    $0x1,%eax
jne    1818 <returnFismatrix+0x638>
jmp    181d <returnFismatrix+0x63d>
jmp    17c8 <returnFismatrix+0x5e8>
lea    -0x430(%rbp),%rdi
mov    -0xc50(%rbp),%rax
mov    -0xc44(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xc44(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
call   10e0 <getArray@plt>
cmp    $0x2,%eax
je     185d <returnFismatrix+0x67d>
lea    0x1859(%rip),%rdi
call   1050 <fisError@plt>
jmp    1862 <returnFismatrix+0x682>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    17ac <returnFismatrix+0x5cc>
mov    -0x30(%rbp),%rdi
call   1070 <fclose@plt>
mov    -0x8(%rbp),%rdi
lea    0x1989(%rip),%rsi
call   1090 <fisOpenFile@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0xc34(%rbp),%ecx
add    -0xc38(%rbp),%ecx
cmp    %ecx,%eax
jge    1a24 <returnFismatrix+0x844>
mov    -0x1c(%rbp),%eax
cmp    -0xc34(%rbp),%eax
jge    18d7 <returnFismatrix+0x6f7>
mov    -0xc58(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc78(%rbp)
ff
jmp    18f7 <returnFismatrix+0x717>
mov    -0xc60(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    -0xc34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc78(%rbp)
ff
movsd  -0xc78(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0xc40(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc40(%rbp),%eax
jge    1a11 <returnFismatrix+0x831>
jmp    1924 <returnFismatrix+0x744>
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   10a0 <getNextLine@plt>
cmp    $0x0,%rax
jne    194a <returnFismatrix+0x76a>
lea    0x1789(%rip),%rdi
call   1050 <fisError@plt>
lea    -0x230(%rbp),%rdi
lea    -0x430(%rbp),%rdx
lea    -0x630(%rbp),%rcx
lea    -0x830(%rbp),%r8
lea    -0xa30(%rbp),%r9
lea    0x177c(%rip),%rsi
mov    $0x0,%al
call   10c0 <sscanf@plt>
cmp    $0x4,%eax
jne    1989 <returnFismatrix+0x7a9>
jmp    198e <returnFismatrix+0x7ae>
jmp    1924 <returnFismatrix+0x744>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0xc7c(%rbp)
lea    -0x630(%rbp),%rdi
call   1080 <strlen@plt>
mov    %rax,%rcx
mov    -0xc7c(%rbp),%eax
cmp    %ecx,%eax
jge    19f4 <returnFismatrix+0x814>
movslq -0x24(%rbp),%rax
movsbl -0x630(%rbp,%rax,1),%eax
ff
cvtsi2sd %eax,%xmm0
mov    -0xc50(%rbp),%rax
movslq -0xc44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1995 <returnFismatrix+0x7b5>
mov    -0xc44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc44(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1910 <returnFismatrix+0x730>
jmp    1a16 <returnFismatrix+0x836>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1894 <returnFismatrix+0x6b4>
mov    -0x30(%rbp),%rdi
call   1070 <fclose@plt>
mov    -0x8(%rbp),%rdi
lea    0x17d5(%rip),%rsi
call   1090 <fisOpenFile@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0xc34(%rbp),%ecx
add    -0xc38(%rbp),%ecx
cmp    %ecx,%eax
jge    1bd8 <returnFismatrix+0x9f8>
mov    -0x1c(%rbp),%eax
cmp    -0xc34(%rbp),%eax
jge    1a8b <returnFismatrix+0x8ab>
mov    -0xc58(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc88(%rbp)
ff
jmp    1aab <returnFismatrix+0x8cb>
mov    -0xc60(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    -0xc34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc88(%rbp)
ff
movsd  -0xc88(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0xc40(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc40(%rbp),%eax
jge    1bc5 <returnFismatrix+0x9e5>
jmp    1ad8 <returnFismatrix+0x8f8>
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   10a0 <getNextLine@plt>
cmp    $0x0,%rax
jne    1afe <returnFismatrix+0x91e>
lea    0x161a(%rip),%rdi
call   1050 <fisError@plt>
lea    -0x230(%rbp),%rdi
lea    -0x430(%rbp),%rdx
lea    -0x630(%rbp),%rcx
lea    -0x830(%rbp),%r8
lea    -0xa30(%rbp),%r9
lea    0x15c8(%rip),%rsi
mov    $0x0,%al
call   10c0 <sscanf@plt>
cmp    $0x4,%eax
jne    1b3d <returnFismatrix+0x95d>
jmp    1b42 <returnFismatrix+0x962>
jmp    1ad8 <returnFismatrix+0x8f8>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0xc8c(%rbp)
lea    -0x830(%rbp),%rdi
call   1080 <strlen@plt>
mov    %rax,%rcx
mov    -0xc8c(%rbp),%eax
cmp    %ecx,%eax
jge    1ba8 <returnFismatrix+0x9c8>
movslq -0x24(%rbp),%rax
movsbl -0x830(%rbp,%rax,1),%eax
ff
cvtsi2sd %eax,%xmm0
mov    -0xc50(%rbp),%rax
movslq -0xc44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1b49 <returnFismatrix+0x969>
mov    -0xc44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc44(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1ac4 <returnFismatrix+0x8e4>
jmp    1bca <returnFismatrix+0x9ea>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1a48 <returnFismatrix+0x868>
mov    -0x30(%rbp),%rdi
call   1070 <fclose@plt>
mov    -0x8(%rbp),%rdi
lea    0x1621(%rip),%rsi
call   1090 <fisOpenFile@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0xc34(%rbp),%ecx
add    -0xc38(%rbp),%ecx
cmp    %ecx,%eax
jge    1ed0 <returnFismatrix+0xcf0>
mov    -0x1c(%rbp),%eax
cmp    -0xc34(%rbp),%eax
jge    1c3f <returnFismatrix+0xa5f>
mov    -0xc58(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc98(%rbp)
ff
jmp    1c5f <returnFismatrix+0xa7f>
mov    -0xc60(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    -0xc34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc98(%rbp)
ff
movsd  -0xc98(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0xc40(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc40(%rbp),%eax
jge    1ebd <returnFismatrix+0xcdd>
jmp    1c8c <returnFismatrix+0xaac>
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   10a0 <getNextLine@plt>
cmp    $0x0,%rax
jne    1cb2 <returnFismatrix+0xad2>
lea    0x1487(%rip),%rdi
call   1050 <fisError@plt>
lea    -0x230(%rbp),%rdi
lea    -0x430(%rbp),%rdx
lea    -0x630(%rbp),%rcx
lea    -0x830(%rbp),%r8
lea    -0xa30(%rbp),%r9
lea    0x1414(%rip),%rsi
mov    $0x0,%al
call   10c0 <sscanf@plt>
cmp    $0x4,%eax
jne    1cf1 <returnFismatrix+0xb11>
jmp    1cf6 <returnFismatrix+0xb16>
jmp    1c8c <returnFismatrix+0xaac>
mov    -0x1c(%rbp),%eax
cmp    -0xc34(%rbp),%eax
jge    1d3d <returnFismatrix+0xb5d>
lea    -0xa30(%rbp),%rdi
mov    -0xc50(%rbp),%rax
movslq -0xc44(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
call   10e0 <getArray@plt>
cmp    $0x4,%eax
jle    1d38 <returnFismatrix+0xb58>
lea    0x1427(%rip),%rdi
call   1050 <fisError@plt>
jmp    1ea0 <returnFismatrix+0xcc0>
lea    -0xc30(%rbp),%rdi
lea    0x1435(%rip),%rsi
call   10b0 <strcmp@plt>
cmp    $0x0,%eax
jne    1d91 <returnFismatrix+0xbb1>
lea    -0xa30(%rbp),%rdi
mov    -0xc50(%rbp),%rax
movslq -0xc44(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
call   10e0 <getArray@plt>
cmp    $0x4,%eax
jle    1d8c <returnFismatrix+0xbac>
lea    0x1401(%rip),%rdi
call   1050 <fisError@plt>
jmp    1e9b <returnFismatrix+0xcbb>
lea    -0xa30(%rbp),%rdi
mov    -0xc50(%rbp),%rax
movslq -0xc44(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
call   10e0 <getArray@plt>
mov    %eax,-0xc64(%rbp)
lea    -0x830(%rbp),%rdi
lea    0x13ec(%rip),%rsi
call   10b0 <strcmp@plt>
cmp    $0x0,%eax
jne    1e41 <returnFismatrix+0xc61>
cmpl   $0x1,-0xc64(%rbp)
je     1def <returnFismatrix+0xc0f>
lea    0x13d3(%rip),%rdi
call   1050 <fisError@plt>
jmp    1e3c <returnFismatrix+0xc5c>
mov    -0xc50(%rbp),%rax
movslq -0xc44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    -0xc50(%rbp),%rax
movslq -0xc44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc50(%rbp),%rax
movslq -0xc44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
jmp    1e96 <returnFismatrix+0xcb6>
lea    -0x830(%rbp),%rdi
lea    0x13b9(%rip),%rsi
call   10b0 <strcmp@plt>
cmp    $0x0,%eax
jne    1e85 <returnFismatrix+0xca5>
mov    -0xc64(%rbp),%eax
mov    -0xc34(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
je     1e80 <returnFismatrix+0xca0>
lea    0x1394(%rip),%rdi
call   1050 <fisError@plt>
jmp    1e91 <returnFismatrix+0xcb1>
lea    0x13d4(%rip),%rdi
call   1050 <fisError@plt>
jmp    1e96 <returnFismatrix+0xcb6>
jmp    1e9b <returnFismatrix+0xcbb>
jmp    1ea0 <returnFismatrix+0xcc0>
mov    -0xc44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc44(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1c78 <returnFismatrix+0xa98>
jmp    1ec2 <returnFismatrix+0xce2>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1bfc <returnFismatrix+0xa1c>
mov    -0x30(%rbp),%rdi
call   1070 <fclose@plt>
mov    -0x8(%rbp),%rdi
lea    0x1329(%rip),%rsi
call   1090 <fisOpenFile@plt>
mov    %rax,-0x30(%rbp)
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   10a0 <getNextLine@plt>
cmp    $0x0,%rax
jne    1f13 <returnFismatrix+0xd33>
lea    0x137c(%rip),%rdi
call   1050 <fisError@plt>
lea    -0x230(%rbp),%rdi
lea    0x138a(%rip),%rsi
call   10b0 <strcmp@plt>
cmp    $0x0,%eax
jne    1f34 <returnFismatrix+0xd54>
jmp    1f39 <returnFismatrix+0xd59>
jmp    1eed <returnFismatrix+0xd0d>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc3c(%rbp),%eax
jge    2076 <returnFismatrix+0xe96>
lea    -0x230(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   10a0 <getNextLine@plt>
cmp    $0x0,%rax
jne    1f75 <returnFismatrix+0xd95>
lea    0x1343(%rip),%rdi
call   1050 <fisError@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0xc9c(%rbp)
lea    -0x230(%rbp),%rdi
call   1080 <strlen@plt>
mov    %rax,%rcx
mov    -0xc9c(%rbp),%eax
cmp    %ecx,%eax
jge    2015 <returnFismatrix+0xe35>
movslq -0x20(%rbp),%rax
movsbl -0x230(%rbp,%rax,1),%eax
ff
cmp    $0x2c,%eax
je     1ff6 <returnFismatrix+0xe16>
movslq -0x20(%rbp),%rax
movsbl -0x230(%rbp,%rax,1),%eax
ff
cmp    $0x28,%eax
je     1ff6 <returnFismatrix+0xe16>
movslq -0x20(%rbp),%rax
movsbl -0x230(%rbp,%rax,1),%eax
ff
cmp    $0x29,%eax
je     1ff6 <returnFismatrix+0xe16>
movslq -0x20(%rbp),%rax
movsbl -0x230(%rbp,%rax,1),%eax
ff
cmp    $0x3a,%eax
jne    2002 <returnFismatrix+0xe22>
movslq -0x20(%rbp),%rax
movb   $0x20,-0x230(%rbp,%rax,1)
jmp    2007 <returnFismatrix+0xe27>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1f7c <returnFismatrix+0xd9c>
lea    -0x230(%rbp),%rdi
mov    -0xc50(%rbp),%rax
mov    -0xc44(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xc44(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
call   10e0 <getArray@plt>
mov    -0xc34(%rbp),%ecx
add    -0xc38(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
je     2063 <returnFismatrix+0xe83>
lea    0x1277(%rip),%rdi
call   1050 <fisError@plt>
jmp    2068 <returnFismatrix+0xe88>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1f40 <returnFismatrix+0xd60>
mov    -0x30(%rbp),%rdi
call   1070 <fclose@plt>
mov    -0xc58(%rbp),%rdi
call   1040 <free@plt>
mov    -0xc60(%rbp),%rdi
call   1040 <free@plt>
mov    -0xc50(%rbp),%rax
add    $0xca0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<returnFismatrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc78,%rsp
mov    %rdi,%rbx
call   10e0 <returnEmptyFismatrix@plt>
mov    %rax,0x10(%rsp)
lea    0x1010(%rip),%rsi
mov    %rbx,0x30(%rsp)
mov    %rbx,%rdi
call   1090 <fisOpenFile@plt>
mov    %rax,%r14
lea    0x80(%rsp),%rbx
lea    0xdec(%rip),%r15
movabs $0x5d6d65747379535b,%rbp
65 6d 5d
jmp    1238 <returnFismatrix+0x68>
mov    0x80(%rsp),%rax
xor    %rbp,%rax
movzbl 0x88(%rsp),%ecx
or     %rax,%rcx
je     1252 <returnFismatrix+0x82>
mov    %rbx,%rdi
mov    %r14,%rsi
call   10a0 <getNextLine@plt>
test   %rax,%rax
jne    1220 <returnFismatrix+0x50>
mov    %r15,%rdi
call   1050 <fisError@plt>
jmp    1220 <returnFismatrix+0x50>
mov    0x10(%rsp),%rbp
mov    0x0(%rbp),%rdx
lea    0x80(%rsp),%rbx
mov    %rbx,%rdi
mov    %r14,%rsi
call   1030 <getString@plt>
mov    0x8(%rbp),%rdx
mov    %rbx,%rdi
mov    %r14,%rsi
call   1030 <getString@plt>
mov    0x8(%rbp),%rcx
mov    $0x1,%eax
xorpd  %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jne    129e <returnFismatrix+0xce>
jnp    12d4 <returnFismatrix+0x104>
cvttsd2si %xmm1,%edx
mov    %dl,0x87f(%rsp,%rax,1)
movsd  (%rcx,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jne    12b6 <returnFismatrix+0xe6>
jnp    12d8 <returnFismatrix+0x108>
cvttsd2si %xmm1,%edx
mov    %dl,0x880(%rsp,%rax,1)
add    $0x2,%rax
cmp    $0x1f5,%rax
jne    1290 <returnFismatrix+0xc0>
mov    $0x1f4,%eax
jmp    12d8 <returnFismatrix+0x108>
add    $0xffffffffffffffff,%rax
mov    %eax,%eax
movb   $0x0,0x880(%rsp,%rax,1)
lea    0x80(%rsp),%rbx
mov    %rbx,%rdi
mov    %r14,%rsi
call   10c0 <getNumber@plt>
mov    %rax,0x48(%rsp)
mov    %eax,%ebp
mov    %rbx,%rdi
mov    %r14,%rsi
call   10c0 <getNumber@plt>
mov    %rax,%r13
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
mov    0x10(%rsp),%rax
mov    0x10(%rax),%rax
movsd  %xmm0,(%rax)
xorps  %xmm0,%xmm0
cvtsi2sd %r13d,%xmm0
movsd  %xmm0,0x8(%rax)
mov    %ebp,%edi
mov    $0x8,%esi
call   1060 <fisCalloc@plt>
mov    %rax,%rbx
mov    %r13d,%edi
mov    $0x8,%esi
call   1060 <fisCalloc@plt>
mov    0x30(%rsp),%rdi
mov    %ebp,%esi
mov    %rbx,%rdx
mov    %r13d,%ecx
mov    %rax,0x20(%rsp)
mov    %rax,%r8
call   10f0 <getMfN@plt>
mov    %rbp,%rax
mov    %rbp,0x68(%rsp)
test   %ebp,%ebp
jle    1458 <returnFismatrix+0x288>
mov    0x10(%rsp),%rax
mov    0x18(%rax),%rax
mov    0x48(%rsp),%ecx
cmp    $0x4,%rcx
jb     139a <returnFismatrix+0x1ca>
lea    (%rbx,%rcx,8),%rdx
cmp    %rdx,%rax
jae    1419 <returnFismatrix+0x249>
lea    (%rax,%rcx,8),%rdx
cmp    %rdx,%rbx
jae    1419 <returnFismatrix+0x249>
xor    %edx,%edx
mov    0x48(%rsp),%rdi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
and    $0x3,%rdi
je     13d4 <returnFismatrix+0x204>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rax,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    13c0 <returnFismatrix+0x1f0>
cmp    $0x3,%rsi
jb     1458 <returnFismatrix+0x288>
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rax,%rdx,8)
movsd  0x8(%rbx,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rdx,8)
movsd  0x10(%rbx,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rdx,8)
movsd  0x18(%rbx,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rax,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    13e0 <returnFismatrix+0x210>
jmp    1458 <returnFismatrix+0x288>
mov    0x48(%rsp),%rsi
and    $0x3,%esi
mov    %rcx,%rdx
sub    %rsi,%rdx
xor    %edi,%edi
nopl   0x0(%rax)
movupd (%rbx,%rdi,8),%xmm0
movupd 0x10(%rbx,%rdi,8),%xmm1
movupd %xmm0,(%rax,%rdi,8)
movupd %xmm1,0x10(%rax,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    1430 <returnFismatrix+0x260>
test   %rsi,%rsi
jne    139c <returnFismatrix+0x1cc>
test   %r13d,%r13d
mov    0x20(%rsp),%rbp
jle    1549 <returnFismatrix+0x379>
mov    0x10(%rsp),%rax
mov    0x20(%rax),%rax
mov    %r13d,%ecx
cmp    $0x4,%rcx
jb     1495 <returnFismatrix+0x2c5>
lea    0x0(,%rcx,8),%rdx
add    %rbp,%rdx
cmp    %rdx,%rax
jae    150a <returnFismatrix+0x33a>
lea    (%rax,%rcx,8),%rdx
cmp    %rdx,%rbp
jae    150a <returnFismatrix+0x33a>
xor    %edx,%edx
mov    %r13d,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
and    $0x3,%rdi
je     14c5 <returnFismatrix+0x2f5>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,(%rax,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    14b0 <returnFismatrix+0x2e0>
cmp    $0x3,%rsi
jb     1549 <returnFismatrix+0x379>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,(%rax,%rdx,8)
movsd  0x8(%rbp,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rdx,8)
movsd  0x10(%rbp,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rdx,8)
movsd  0x18(%rbp,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rax,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    14d0 <returnFismatrix+0x300>
jmp    1549 <returnFismatrix+0x379>
mov    %r13d,%esi
and    $0x3,%esi
mov    %rcx,%rdx
sub    %rsi,%rdx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rdi,8),%xmm0
movupd 0x10(%rbp,%rdi,8),%xmm1
movupd %xmm0,(%rax,%rdi,8)
movupd %xmm1,0x10(%rax,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    1520 <returnFismatrix+0x350>
test   %rsi,%rsi
jne    1497 <returnFismatrix+0x2c7>
mov    %rbx,0x38(%rsp)
lea    0x80(%rsp),%rbp
mov    %rbp,%rdi
mov    %r14,%rsi
call   10c0 <getNumber@plt>
mov    %rax,0x78(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x10(%rsp),%rbx
mov    0x28(%rbx),%rax
movsd  %xmm0,(%rax)
mov    0x30(%rbx),%rdx
mov    %rbp,%rdi
mov    %r14,%rsi
call   1030 <getString@plt>
mov    0x38(%rbx),%rdx
mov    %rbp,%rdi
mov    %r14,%rsi
call   1030 <getString@plt>
mov    0x40(%rbx),%rdx
mov    %rbp,%rdi
mov    %r14,%rsi
call   1030 <getString@plt>
mov    0x48(%rbx),%rdx
mov    %rbp,%rdi
mov    %r14,%rsi
call   1030 <getString@plt>
mov    0x50(%rbx),%rdx
mov    %rbp,%rdi
mov    %r14,%rsi
call   1030 <getString@plt>
mov    %r14,%rdi
call   1070 <fclose@plt>
lea    0xc31(%rip),%rsi
mov    0x30(%rsp),%rdi
call   1090 <fisOpenFile@plt>
mov    %rax,%r12
lea    0xa43(%rip),%r14
lea    0xa64(%rip),%r15
lea    0x480(%rsp),%rbx
jmp    1615 <returnFismatrix+0x445>
nopl   0x0(%rax)
mov    %rbp,%rdi
mov    %r15,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   10b0 <sscanf@plt>
cmp    $0x1,%eax
je     162f <returnFismatrix+0x45f>
mov    %rbp,%rdi
mov    %r12,%rsi
call   10a0 <getNextLine@plt>
test   %rax,%rax
jne    1600 <returnFismatrix+0x430>
mov    %r14,%rdi
call   1050 <fisError@plt>
jmp    1600 <returnFismatrix+0x430>
mov    0x68(%rsp),%rax
lea    (%rax,%r13,1),%ebp
test   %ebp,%ebp
mov    %rbp,0x28(%rsp)
jle    1723 <returnFismatrix+0x553>
lea    0xb(%rbp),%eax
mov    %rax,0x8(%rsp)
mov    $0xb,%eax
mov    %rax,0x18(%rsp)
lea    0x80(%rsp),%rbp
lea    0x9fe(%rip),%r14
lea    0x9e6(%rip),%r15
lea    0x480(%rsp),%rbx
jmp    1695 <returnFismatrix+0x4c5>
nopw   0x0(%rax,%rax,1)
mov    %rbp,%rdi
mov    %r15,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   10b0 <sscanf@plt>
cmp    $0x1,%eax
je     16af <returnFismatrix+0x4df>
mov    %rbp,%rdi
mov    %r12,%rsi
call   10a0 <getNextLine@plt>
test   %rax,%rax
jne    1680 <returnFismatrix+0x4b0>
mov    %r14,%rdi
call   1050 <fisError@plt>
jmp    1680 <returnFismatrix+0x4b0>
mov    %rbx,%rdi
call   1080 <strlen@plt>
test   %eax,%eax
jle    16f9 <returnFismatrix+0x529>
mov    0x10(%rsp),%rax
mov    0x18(%rsp),%rcx
mov    (%rax,%rcx,8),%r14
xor    %r13d,%r13d
nopl   0x0(%rax)
movsbl 0x480(%rsp,%r13,1),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r14,%r13,8)
add    $0x1,%r13
mov    %rbx,%rdi
call   1080 <strlen@plt>
cltq
cmp    %rax,%r13
jl     16d0 <returnFismatrix+0x500>
mov    0x18(%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x18(%rsp)
cmp    0x8(%rsp),%rcx
lea    0x94e(%rip),%r14
jne    1695 <returnFismatrix+0x4c5>
mov    0x28(%rsp),%rbp
jmp    172d <returnFismatrix+0x55d>
mov    $0xb,%eax
mov    %rax,0x8(%rsp)
mov    %r12,%rdi
call   1070 <fclose@plt>
lea    0xac9(%rip),%rsi
mov    0x30(%rsp),%rdi
call   1090 <fisOpenFile@plt>
mov    %rax,%rbx
test   %ebp,%ebp
jle    17ec <returnFismatrix+0x61c>
mov    0x8(%rsp),%rax
mov    %eax,%eax
mov    %rax,0x8(%rsp)
lea    0x80(%rsp),%rbp
lea    0x915(%rip),%r14
lea    0x92c(%rip),%r15
lea    0x480(%rsp),%r12
xor    %r13d,%r13d
jmp    1795 <returnFismatrix+0x5c5>
mov    %rbp,%rdi
mov    %r15,%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   10b0 <sscanf@plt>
cmp    $0x1,%eax
je     17af <returnFismatrix+0x5df>
mov    %rbp,%rdi
mov    %rbx,%rsi
call   10a0 <getNextLine@plt>
test   %rax,%rax
jne    1780 <returnFismatrix+0x5b0>
mov    %r14,%rdi
call   1050 <fisError@plt>
jmp    1780 <returnFismatrix+0x5b0>
mov    0x10(%rsp),%rax
mov    0x8(%rsp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    %r12,%rdi
call   10d0 <getArray@plt>
cmp    $0x2,%eax
je     17d6 <returnFismatrix+0x606>
lea    0x8e0(%rip),%rdi
call   1050 <fisError@plt>
addq   $0x1,0x8(%rsp)
add    $0x1,%r13d
cmp    0x28(%rsp),%r13d
jne    1795 <returnFismatrix+0x5c5>
mov    0x28(%rsp),%rbp
mov    %rbx,%rdi
call   1070 <fclose@plt>
lea    0xa0a(%rip),%rsi
mov    0x30(%rsp),%rdi
call   1090 <fisOpenFile@plt>
mov    %rax,%r15
mov    %ebp,%eax
mov    %rax,0x70(%rsp)
test   %ebp,%ebp
jle    199e <returnFismatrix+0x7ce>
movslq 0x48(%rsp),%rax
mov    %rax,0x58(%rsp)
lea    0x80(%rsp),%r13
lea    0x89e(%rip),%r14
lea    0x8b9(%rip),%rbx
lea    0x480(%rsp),%rbp
lea    0x680(%rsp),%r12
xor    %edi,%edi
mov    0x38(%rsp),%rdx
mov    0x20(%rsp),%rsi
mov    %r15,0x40(%rsp)
jmp    187e <returnFismatrix+0x6ae>
nopw   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rdx
mov    0x20(%rsp),%rsi
mov    0x60(%rsp),%rdi
add    $0x1,%rdi
cmp    0x70(%rsp),%rdi
je     199e <returnFismatrix+0x7ce>
mov    %rdi,%rax
sub    0x58(%rsp),%rax
lea    (%rdx,%rdi,8),%rcx
lea    (%rsi,%rax,8),%rax
cmovl  %rcx,%rax
cvttsd2si (%rax),%eax
mov    %eax,0x50(%rsp)
test   %eax,%eax
jle    186f <returnFismatrix+0x69f>
mov    %rdi,0x60(%rsp)
mov    0x8(%rsp),%rax
cltq
mov    %rax,0x8(%rsp)
xor    %eax,%eax
jmp    18e6 <returnFismatrix+0x716>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addq   $0x1,0x8(%rsp)
mov    0x18(%rsp),%eax
add    $0x1,%eax
cmp    0x50(%rsp),%eax
lea    0x7f6(%rip),%r14
mov    %r15,%r12
mov    0x40(%rsp),%r15
je     1860 <returnFismatrix+0x690>
mov    %eax,0x18(%rsp)
jmp    1918 <returnFismatrix+0x748>
nopl   0x0(%rax)
mov    %r13,%rdi
mov    %rbx,%rsi
mov    %rbp,%rdx
mov    %r12,%rcx
lea    0x280(%rsp),%r8
lea    0xa80(%rsp),%r9
xor    %eax,%eax
call   10b0 <sscanf@plt>
cmp    $0x4,%eax
je     1940 <returnFismatrix+0x770>
mov    %r13,%rdi
mov    %r15,%rsi
call   10a0 <getNextLine@plt>
test   %rax,%rax
jne    18f0 <returnFismatrix+0x720>
mov    %r14,%rdi
call   1050 <fisError@plt>
jmp    18f0 <returnFismatrix+0x720>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r12,%rdi
call   1080 <strlen@plt>
test   %eax,%eax
mov    %r12,%r15
jle    18c0 <returnFismatrix+0x6f0>
mov    0x10(%rsp),%rax
mov    0x8(%rsp),%rcx
mov    (%rax,%rcx,8),%r12
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsbl 0x680(%rsp,%r14,1),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r12,%r14,8)
add    $0x1,%r14
mov    %r15,%rdi
call   1080 <strlen@plt>
cltq
cmp    %rax,%r14
jl     1970 <returnFismatrix+0x7a0>
jmp    18c0 <returnFismatrix+0x6f0>
mov    %r15,%rdi
call   1070 <fclose@plt>
lea    0x858(%rip),%rsi
mov    0x30(%rsp),%rdi
call   1090 <fisOpenFile@plt>
mov    %rax,%r15
cmpl   $0x0,0x28(%rsp)
jle    1b5e <returnFismatrix+0x98e>
movslq 0x48(%rsp),%rax
mov    %rax,0x58(%rsp)
lea    0x71a(%rip),%r13
lea    0x480(%rsp),%rbp
lea    0x680(%rsp),%rbx
lea    0x280(%rsp),%r14
xor    %edi,%edi
mov    0x38(%rsp),%rdx
mov    0x20(%rsp),%rsi
mov    %r15,0x40(%rsp)
jmp    1a2e <returnFismatrix+0x85e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rdx
mov    0x20(%rsp),%rsi
mov    0x60(%rsp),%rdi
add    $0x1,%rdi
cmp    0x70(%rsp),%rdi
je     1b5e <returnFismatrix+0x98e>
mov    %rdi,%rax
sub    0x58(%rsp),%rax
lea    (%rdx,%rdi,8),%rcx
lea    (%rsi,%rax,8),%rax
cmovl  %rcx,%rax
cvttsd2si (%rax),%eax
mov    %eax,0x50(%rsp)
test   %eax,%eax
jle    1a1f <returnFismatrix+0x84f>
mov    %rdi,0x60(%rsp)
mov    0x8(%rsp),%rax
cltq
mov    %rax,0x8(%rsp)
xor    %eax,%eax
jmp    1a97 <returnFismatrix+0x8c7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addq   $0x1,0x8(%rsp)
mov    0x18(%rsp),%eax
add    $0x1,%eax
cmp    0x50(%rsp),%eax
mov    %rbx,%r13
lea    0x680(%rsp),%rbx
mov    0x40(%rsp),%r15
je     1a10 <returnFismatrix+0x840>
mov    %eax,0x18(%rsp)
lea    0x80(%rsp),%r12
jmp    1ad3 <returnFismatrix+0x903>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r12,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
mov    %rbx,%rcx
mov    %r14,%r8
lea    0xa80(%rsp),%r9
xor    %eax,%eax
call   10b0 <sscanf@plt>
cmp    $0x4,%eax
je     1b00 <returnFismatrix+0x930>
mov    %r12,%rdi
mov    %r15,%rsi
call   10a0 <getNextLine@plt>
test   %rax,%rax
jne    1ab0 <returnFismatrix+0x8e0>
lea    0x629(%rip),%rdi
call   1050 <fisError@plt>
jmp    1ab0 <returnFismatrix+0x8e0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r13,%rbx
mov    %r14,%r15
mov    %r14,%rdi
call   1080 <strlen@plt>
test   %eax,%eax
jle    1a70 <returnFismatrix+0x8a0>
mov    0x10(%rsp),%rax
mov    0x8(%rsp),%rcx
mov    (%rax,%rcx,8),%r12
xor    %r13d,%r13d
nopw   0x0(%rax,%rax,1)
movsbl 0x280(%rsp,%r13,1),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r12,%r13,8)
add    $0x1,%r13
mov    %r15,%rdi
call   1080 <strlen@plt>
cltq
cmp    %rax,%r13
jl     1b30 <returnFismatrix+0x960>
jmp    1a70 <returnFismatrix+0x8a0>
mov    %r15,%rdi
call   1070 <fclose@plt>
lea    0x698(%rip),%rsi
mov    0x30(%rsp),%rdi
call   1090 <fisOpenFile@plt>
mov    %rax,%rbp
cmpl   $0x0,0x28(%rsp)
jle    1da5 <returnFismatrix+0xbd5>
mov    0x880(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    0x68(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x68(%rsp)
movslq 0x48(%rsp),%rax
mov    %rax,0x40(%rsp)
lea    0x80(%rsp),%rbx
lea    0x480(%rsp),%r12
lea    0x680(%rsp),%r13
lea    0x280(%rsp),%r14
lea    0xa80(%rsp),%r15
xor    %ecx,%ecx
mov    0x38(%rsp),%rdx
mov    0x20(%rsp),%rsi
jmp    1bfe <returnFismatrix+0xa2e>
nop
mov    0x38(%rsp),%rdx
mov    0x20(%rsp),%rsi
mov    0x50(%rsp),%rcx
add    $0x1,%rcx
cmp    0x70(%rsp),%rcx
je     1da5 <returnFismatrix+0xbd5>
mov    %rcx,%rax
sub    0x40(%rsp),%rax
mov    %rcx,0x50(%rsp)
lea    (%rdx,%rcx,8),%rcx
lea    (%rsi,%rax,8),%rax
cmovl  %rcx,%rax
cvttsd2si (%rax),%eax
mov    %eax,0x60(%rsp)
test   %eax,%eax
jle    1bea <returnFismatrix+0xa1a>
mov    0x8(%rsp),%rax
cltq
mov    %rax,0x8(%rsp)
xor    %eax,%eax
jmp    1c58 <returnFismatrix+0xa88>
lea    0x61e(%rip),%rdi
nopw   0x0(%rax,%rax,1)
call   1050 <fisError@plt>
addq   $0x1,0x8(%rsp)
mov    0x18(%rsp),%eax
add    $0x1,%eax
cmp    0x60(%rsp),%eax
je     1be0 <returnFismatrix+0xa10>
mov    %eax,0x18(%rsp)
jmp    1c82 <returnFismatrix+0xab2>
xchg   %ax,%ax
mov    %rbx,%rdi
lea    0x486(%rip),%rsi
mov    %r12,%rdx
mov    %r13,%rcx
mov    %r14,%r8
mov    %r15,%r9
xor    %eax,%eax
call   10b0 <sscanf@plt>
cmp    $0x4,%eax
je     1ca0 <returnFismatrix+0xad0>
mov    %rbx,%rdi
mov    %rbp,%rsi
call   10a0 <getNextLine@plt>
test   %rax,%rax
jne    1c60 <returnFismatrix+0xa90>
lea    0x49b(%rip),%rdi
call   1050 <fisError@plt>
jmp    1c60 <returnFismatrix+0xa90>
mov    0x10(%rsp),%rax
mov    0x8(%rsp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    %r15,%rdi
call   10d0 <getArray@plt>
mov    0x50(%rsp),%rcx
cmp    0x40(%rsp),%rcx
jge    1ce0 <returnFismatrix+0xb10>
cmp    $0x5,%eax
jl     1c45 <returnFismatrix+0xa75>
lea    0x488(%rip),%rdi
jmp    1c40 <returnFismatrix+0xa70>
nopw   0x0(%rax,%rax,1)
movabs $0x696e61646d616d,%rcx
cmp    %rcx,0x58(%rsp)
jne    1d10 <returnFismatrix+0xb40>
cmp    $0x5,%eax
jl     1c45 <returnFismatrix+0xa75>
lea    0x47f(%rip),%rdi
jmp    1c40 <returnFismatrix+0xa70>
cs nopw 0x0(%rax,%rax,1)
mov    0x280(%rsp),%rcx
movabs $0x746e6174736e6f63,%rdx
61 6e 74
xor    %rdx,%rcx
movzbl 0x288(%rsp),%edx
or     %rcx,%rdx
je     1d6c <returnFismatrix+0xb9c>
mov    0x280(%rsp),%ecx
mov    $0x656e696c,%edx
xor    %edx,%ecx
mov    0x283(%rsp),%edx
mov    $0x726165,%esi
xor    %esi,%edx
or     %ecx,%edx
jne    1c33 <returnFismatrix+0xa63>
cmp    0x68(%rsp),%eax
je     1c45 <returnFismatrix+0xa75>
lea    0x4a0(%rip),%rdi
jmp    1c40 <returnFismatrix+0xa70>
cmp    $0x1,%eax
jne    1d99 <returnFismatrix+0xbc9>
mov    0x10(%rsp),%rax
mov    0x8(%rsp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    0x40(%rsp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movq   $0x0,(%rax)
jmp    1c45 <returnFismatrix+0xa75>
lea    0x410(%rip),%rdi
jmp    1c40 <returnFismatrix+0xa70>
mov    %rbp,%rdi
call   1070 <fclose@plt>
lea    0x451(%rip),%rsi
mov    0x30(%rsp),%rdi
call   1090 <fisOpenFile@plt>
mov    %rax,%rbx
lea    0x80(%rsp),%r12
lea    0x4b2(%rip),%r14
movabs $0x5d73656c75525b,%rbp
mov    0x28(%rsp),%r15
jmp    1dfa <returnFismatrix+0xc2a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %rbp,0x80(%rsp)
je     1e14 <returnFismatrix+0xc44>
mov    %r12,%rdi
mov    %rbx,%rsi
call   10a0 <getNextLine@plt>
test   %rax,%rax
jne    1df0 <returnFismatrix+0xc20>
mov    %r14,%rdi
call   1050 <fisError@plt>
jmp    1df0 <returnFismatrix+0xc20>
cmpl   $0x0,0x78(%rsp)
jle    1f10 <returnFismatrix+0xd40>
add    $0x2,%r15d
movslq 0x8(%rsp),%r12
xor    %r13d,%r13d
lea    0x80(%rsp),%rbp
movabs $0x400130000000000,%r14
mov    %rbx,0x18(%rsp)
mov    %r15,0x28(%rsp)
jmp    1e68 <returnFismatrix+0xc98>
nopl   0x0(%rax)
add    $0x1,%r12
add    $0x1,%r13d
cmp    0x78(%rsp),%r13d
mov    0x18(%rsp),%rbx
je     1f10 <returnFismatrix+0xd40>
mov    %rbp,%rdi
mov    %rbx,%rsi
call   10a0 <getNextLine@plt>
test   %rax,%rax
jne    1e84 <returnFismatrix+0xcb4>
lea    0x424(%rip),%rdi
call   1050 <fisError@plt>
mov    %rbp,%rdi
call   1080 <strlen@plt>
test   %eax,%eax
jle    1ee0 <returnFismatrix+0xd10>
xor    %r15d,%r15d
jmp    1eb3 <returnFismatrix+0xce3>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r15
mov    %rbp,%rdi
call   1080 <strlen@plt>
cltq
cmp    %rax,%r15
jge    1ee0 <returnFismatrix+0xd10>
movzbl 0x80(%rsp,%r15,1),%eax
cmp    $0x3a,%rax
ja     1ea0 <returnFismatrix+0xcd0>
bt     %rax,%r14
jae    1ea0 <returnFismatrix+0xcd0>
movb   $0x20,0x80(%rsp,%r15,1)
jmp    1ea0 <returnFismatrix+0xcd0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x10(%rsp),%rax
mov    (%rax,%r12,8),%rsi
mov    %rbp,%rdi
call   10d0 <getArray@plt>
mov    0x28(%rsp),%r15
cmp    %r15d,%eax
je     1e50 <returnFismatrix+0xc80>
lea    0x3bf(%rip),%rdi
call   1050 <fisError@plt>
jmp    1e50 <returnFismatrix+0xc80>
mov    %rbx,%rdi
call   1070 <fclose@plt>
mov    0x38(%rsp),%rdi
call   1040 <free@plt>
mov    0x20(%rsp),%rdi
call   1040 <free@plt>
mov    0x10(%rsp),%rax
add    $0xc78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [2 x i8] c"r\00"
@.str.1 = [34 x i8] c"Cannot find [System] in FIS file!\00"
@.str.2 = [9 x i8] c"[System]\00"
@.str.3 = [40 x i8] c"Cannot find the first Name in FIS file!\00"
@.str.4 = [17 x i8] c" Name = '%[^']' \00"
@.str.5 = [29 x i8] c"Not enough Name in FIS file!\00"
@.str.6 = [30 x i8] c"Not enough Range in FIS file!\00"
@.str.7 = [18 x i8] c" Range = [ %[^]] \00"
@.str.8 = [29 x i8] c"Error in parsing I/O ranges.\00"
@.str.9 = [34 x i8] c"Not enough MF Labels in FIS file!\00"
@.str.10 = [35 x i8] c" %[^']'%[^']' : '%[^']' , [ %[^]] \00"
@.str.11 = [33 x i8] c"Not enough MF types in FIS file!\00"
@.str.12 = [38 x i8] c"Not enough MF parameters in FIS file!\00"
@.str.13 = [38 x i8] c"Error in parsing input MF parameters.\00"
@.str.15 = [39 x i8] c"Error in parsing output MF parameters.\00"
@.str.16 = [9 x i8] c"constant\00"
@.str.17 = [80 x i8] c"Zero-order Sugeno system does not has the right number of output MF parameters.\00"
@.str.18 = [7 x i8] c"linear\00"
@.str.19 = [81 x i8] c"First-order Sugeno system does not has the right number of output MF parameters.\00"
@.str.20 = [42 x i8] c"Unknown output MF type for Sugeno system.\00"
@.str.21 = [33 x i8] c"Cannot find [Rules] in FIS file!\00"
@.str.23 = [34 x i8] c"Not enough rule list in FIS file!\00"
@.str.24 = [28 x i8] c"Error in parsing rule list!\00"
define double** @returnFismatrix(i8* %0, i32* %1, i32* %2) {
%4 = alloca [500 x i8]
%5 = alloca [500 x i8]
%6 = alloca [500 x i8]
%7 = alloca [500 x i8]
%8 = alloca [500 x i8]
%9 = alloca [500 x i8]
%10 = getelementptr inbounds [500 x i8], [500 x i8]* %4, i64 0, i64 0
%11 = getelementptr inbounds [500 x i8], [500 x i8]* %5, i64 0, i64 0
%12 = getelementptr inbounds [500 x i8], [500 x i8]* %6, i64 0, i64 0
%13 = getelementptr inbounds [500 x i8], [500 x i8]* %7, i64 0, i64 0
%14 = getelementptr inbounds [500 x i8], [500 x i8]* %8, i64 0, i64 0
%15 = getelementptr inbounds [500 x i8], [500 x i8]* %9, i64 0, i64 0
%16 = tail call double** @returnEmptyFismatrix(i8* %0, i32* %1, i32* %2)
%17 = tail call i32* @fisOpenFile(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
br label %18
18: ; preds = %23, %3
%19 = call i32* @getNextLine(i8* %10, i32* %17)
%20 = icmp eq i32* %19, null
br i1 %20, label %21, label %23
21: ; preds = %18
%22 = call i32 @fisError(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0))
br label %23
23: ; preds = %21, %18
%24 = call i32 @bcmp(i8* dereferenceable(9) %10, i8* dereferenceable(9) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), i64 9)
%25 = icmp eq i32 %24, 0
br i1 %25, label %26, label %18
26: ; preds = %23
%27 = load double*, double** %16
%28 = call i32 @getString(i8* %10, i32* %17, double* %27)
%29 = getelementptr inbounds double*, double** %16, i64 1
%30 = load double*, double** %29
%31 = call i32 @getString(i8* %10, i32* %17, double* %30)
%32 = load double*, double** %29
br label %33
33: ; preds = %46, %26
%34 = phi i64 [ 0, %26 ], [ %50, %46 ]
%35 = getelementptr inbounds double, double* %32, i64 %34
%36 = load double, double* %35
%37 = fcmp une double %36, 0.000000e+00
br i1 %37, label %38, label %52
38: ; preds = %33
%39 = fptosi double %36 to i32
%40 = trunc i32 %39 to i8
%41 = getelementptr inbounds [500 x i8], [500 x i8]* %9, i64 0, i64 %34
store i8 %40, i8* %41
%42 = or i64 %34, 1
%43 = getelementptr inbounds double, double* %32, i64 %42
%44 = load double, double* %43
%45 = fcmp une double %44, 0.000000e+00
br i1 %45, label %46, label %52
46: ; preds = %38
%47 = fptosi double %44 to i32
%48 = trunc i32 %47 to i8
%49 = getelementptr inbounds [500 x i8], [500 x i8]* %9, i64 0, i64 %42
store i8 %48, i8* %49
%50 = add nuw nsw i64 %34, 2
%51 = icmp eq i64 %50, 500
br i1 %51, label %52, label %33
52: ; preds = %46, %38, %33
%53 = phi i64 [ %34, %33 ], [ %42, %38 ], [ 500, %46 ]
%54 = and i64 %53, 4294967295
%55 = getelementptr inbounds [500 x i8], [500 x i8]* %9, i64 0, i64 %54
store i8 0, i8* %55
%56 = call i64 @getNumber(i8* %10, i32* %17)
%57 = trunc i64 %56 to i32
%58 = call i64 @getNumber(i8* %10, i32* %17)
%59 = trunc i64 %58 to i32
%60 = sitofp i32 %57 to double
%61 = getelementptr inbounds double*, double** %16, i64 2
%62 = load double*, double** %61
store double %60, double* %62
%63 = sitofp i32 %59 to double
%64 = getelementptr inbounds double, double* %62, i64 1
store double %63, double* %64
%65 = call i64 @fisCalloc(i32 %57, i32 8)
%66 = inttoptr i64 %65 to double*
%67 = inttoptr i64 %65 to i8*
%68 = call i64 @fisCalloc(i32 %59, i32 8)
%69 = inttoptr i64 %68 to double*
%70 = inttoptr i64 %68 to i8*
%71 = call i32 @getMfN(i8* %0, i32 %57, double* %66, i32 %59, double* %69)
%72 = icmp sgt i32 %57, 0
br i1 %72, label %73, label %123
73: ; preds = %52
%74 = getelementptr inbounds double*, double** %16, i64 3
%75 = load double*, double** %74
%76 = and i64 %56, 4294967295
%77 = icmp ult i64 %76, 4
br i1 %77, label %104, label %78
78: ; preds = %73
%79 = getelementptr double, double* %75, i64 %76
%80 = bitcast double* %79 to i8*
%81 = getelementptr double, double* %66, i64 %76
%82 = icmp ult double* %75, %81
%83 = icmp ult i8* %67, %80
%84 = and i1 %82, %83
br i1 %84, label %104, label %85
85: ; preds = %78
%86 = and i64 %56, 3
%87 = sub nsw i64 %76, %86
br label %88
88: ; preds = %88, %85
%89 = phi i64 [ 0, %85 ], [ %100, %88 ]
%90 = getelementptr inbounds double, double* %66, i64 %89
%91 = bitcast double* %90 to <2 x double>*
%92 = load <2 x double>, <2 x double>* %91
%93 = getelementptr inbounds double, double* %90, i64 2
%94 = bitcast double* %93 to <2 x double>*
%95 = load <2 x double>, <2 x double>* %94
%96 = getelementptr inbounds double, double* %75, i64 %89
%97 = bitcast double* %96 to <2 x double>*
store <2 x double> %92, <2 x double>* %97
%98 = getelementptr inbounds double, double* %96, i64 2
%99 = bitcast double* %98 to <2 x double>*
store <2 x double> %95, <2 x double>* %99
%100 = add nuw i64 %89, 4
%101 = icmp eq i64 %100, %87
br i1 %101, label %102, label %88
102: ; preds = %88
%103 = icmp eq i64 %86, 0
br i1 %103, label %123, label %104
104: ; preds = %78, %73, %102
%105 = phi i64 [ 0, %78 ], [ 0, %73 ], [ %87, %102 ]
%106 = sub i64 %56, %105
%107 = xor i64 %105, -1
%108 = add nsw i64 %76, %107
%109 = and i64 %106, 3
%110 = icmp eq i64 %109, 0
br i1 %110, label %120, label %111
111: ; preds = %104, %111
%112 = phi i64 [ %117, %111 ], [ %105, %104 ]
%113 = phi i64 [ %118, %111 ], [ 0, %104 ]
%114 = getelementptr inbounds double, double* %66, i64 %112
%115 = load double, double* %114
%116 = getelementptr inbounds double, double* %75, i64 %112
store double %115, double* %116
%117 = add nuw nsw i64 %112, 1
%118 = add i64 %113, 1
%119 = icmp eq i64 %118, %109
br i1 %119, label %120, label %111
120: ; preds = %111, %104
%121 = phi i64 [ %105, %104 ], [ %117, %111 ]
%122 = icmp ult i64 %108, 3
br i1 %122, label %123, label %175
123: ; preds = %120, %175, %102, %52
%124 = icmp sgt i32 %59, 0
br i1 %124, label %125, label %213
125: ; preds = %123
%126 = getelementptr inbounds double*, double** %16, i64 4
%127 = load double*, double** %126
%128 = and i64 %58, 4294967295
%129 = icmp ult i64 %128, 4
br i1 %129, label %156, label %130
130: ; preds = %125
%131 = getelementptr double, double* %127, i64 %128
%132 = bitcast double* %131 to i8*
%133 = getelementptr double, double* %69, i64 %128
%134 = icmp ult double* %127, %133
%135 = icmp ult i8* %70, %132
%136 = and i1 %134, %135
br i1 %136, label %156, label %137
137: ; preds = %130
%138 = and i64 %58, 3
%139 = sub nsw i64 %128, %138
br label %140
140: ; preds = %140, %137
%141 = phi i64 [ 0, %137 ], [ %152, %140 ]
%142 = getelementptr inbounds double, double* %69, i64 %141
%143 = bitcast double* %142 to <2 x double>*
%144 = load <2 x double>, <2 x double>* %143
%145 = getelementptr inbounds double, double* %142, i64 2
%146 = bitcast double* %145 to <2 x double>*
%147 = load <2 x double>, <2 x double>* %146
%148 = getelementptr inbounds double, double* %127, i64 %141
%149 = bitcast double* %148 to <2 x double>*
store <2 x double> %144, <2 x double>* %149
%150 = getelementptr inbounds double, double* %148, i64 2
%151 = bitcast double* %150 to <2 x double>*
store <2 x double> %147, <2 x double>* %151
%152 = add nuw i64 %141, 4
%153 = icmp eq i64 %152, %139
br i1 %153, label %154, label %140
154: ; preds = %140
%155 = icmp eq i64 %138, 0
br i1 %155, label %213, label %156
156: ; preds = %130, %125, %154
%157 = phi i64 [ 0, %130 ], [ 0, %125 ], [ %139, %154 ]
%158 = sub i64 %58, %157
%159 = xor i64 %157, -1
%160 = add nsw i64 %128, %159
%161 = and i64 %158, 3
%162 = icmp eq i64 %161, 0
br i1 %162, label %172, label %163
163: ; preds = %156, %163
%164 = phi i64 [ %169, %163 ], [ %157, %156 ]
%165 = phi i64 [ %170, %163 ], [ 0, %156 ]
%166 = getelementptr inbounds double, double* %69, i64 %164
%167 = load double, double* %166
%168 = getelementptr inbounds double, double* %127, i64 %164
store double %167, double* %168
%169 = add nuw nsw i64 %164, 1
%170 = add i64 %165, 1
%171 = icmp eq i64 %170, %161
br i1 %171, label %172, label %163
172: ; preds = %163, %156
%173 = phi i64 [ %157, %156 ], [ %169, %163 ]
%174 = icmp ult i64 %160, 3
br i1 %174, label %213, label %194
175: ; preds = %120, %175
%176 = phi i64 [ %192, %175 ], [ %121, %120 ]
%177 = getelementptr inbounds double, double* %66, i64 %176
%178 = load double, double* %177
%179 = getelementptr inbounds double, double* %75, i64 %176
store double %178, double* %179
%180 = add nuw nsw i64 %176, 1
%181 = getelementptr inbounds double, double* %66, i64 %180
%182 = load double, double* %181
%183 = getelementptr inbounds double, double* %75, i64 %180
store double %182, double* %183
%184 = add nuw nsw i64 %176, 2
%185 = getelementptr inbounds double, double* %66, i64 %184
%186 = load double, double* %185
%187 = getelementptr inbounds double, double* %75, i64 %184
store double %186, double* %187
%188 = add nuw nsw i64 %176, 3
%189 = getelementptr inbounds double, double* %66, i64 %188
%190 = load double, double* %189
%191 = getelementptr inbounds double, double* %75, i64 %188
store double %190, double* %191
%192 = add nuw nsw i64 %176, 4
%193 = icmp eq i64 %192, %76
br i1 %193, label %123, label %175
194: ; preds = %172, %194
%195 = phi i64 [ %211, %194 ], [ %173, %172 ]
%196 = getelementptr inbounds double, double* %69, i64 %195
%197 = load double, double* %196
%198 = getelementptr inbounds double, double* %127, i64 %195
store double %197, double* %198
%199 = add nuw nsw i64 %195, 1
%200 = getelementptr inbounds double, double* %69, i64 %199
%201 = load double, double* %200
%202 = getelementptr inbounds double, double* %127, i64 %199
store double %201, double* %202
%203 = add nuw nsw i64 %195, 2
%204 = getelementptr inbounds double, double* %69, i64 %203
%205 = load double, double* %204
%206 = getelementptr inbounds double, double* %127, i64 %203
store double %205, double* %206
%207 = add nuw nsw i64 %195, 3
%208 = getelementptr inbounds double, double* %69, i64 %207
%209 = load double, double* %208
%210 = getelementptr inbounds double, double* %127, i64 %207
store double %209, double* %210
%211 = add nuw nsw i64 %195, 4
%212 = icmp eq i64 %211, %128
br i1 %212, label %213, label %194
213: ; preds = %172, %194, %154, %123
%214 = call i64 @getNumber(i8* %10, i32* %17)
%215 = trunc i64 %214 to i32
%216 = sitofp i32 %215 to double
%217 = getelementptr inbounds double*, double** %16, i64 5
%218 = load double*, double** %217
store double %216, double* %218
%219 = getelementptr inbounds double*, double** %16, i64 6
%220 = load double*, double** %219
%221 = call i32 @getString(i8* %10, i32* %17, double* %220)
%222 = getelementptr inbounds double*, double** %16, i64 7
%223 = load double*, double** %222
%224 = call i32 @getString(i8* %10, i32* %17, double* %223)
%225 = getelementptr inbounds double*, double** %16, i64 8
%226 = load double*, double** %225
%227 = call i32 @getString(i8* %10, i32* %17, double* %226)
%228 = getelementptr inbounds double*, double** %16, i64 9
%229 = load double*, double** %228
%230 = call i32 @getString(i8* %10, i32* %17, double* %229)
%231 = getelementptr inbounds double*, double** %16, i64 10
%232 = load double*, double** %231
%233 = call i32 @getString(i8* %10, i32* %17, double* %232)
%234 = call i32 @fclose(i32* %17)
%235 = call i32* @fisOpenFile(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
br label %236
236: ; preds = %241, %213
%237 = call i32* @getNextLine(i8* %10, i32* %235)
%238 = icmp eq i32* %237, null
br i1 %238, label %239, label %241
239: ; preds = %236
%240 = call i32 @fisError(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.3, i64 0, i64 0))
br label %241
241: ; preds = %239, %236
%242 = call i32 (i8*, i8*, i8*, ...) @sscanf(i8* %10, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.4, i64 0, i64 0), i8* %11)
%243 = icmp eq i32 %242, 1
br i1 %243, label %244, label %236
244: ; preds = %241
%245 = add i32 %59, %57
%246 = icmp sgt i32 %245, 0
br i1 %246, label %247, label %281
247: ; preds = %244
%248 = add nuw i32 %245, 11
%249 = zext i32 %248 to i64
br label %250
250: ; preds = %247, %278
%251 = phi i64 [ 11, %247 ], [ %279, %278 ]
br label %252
252: ; preds = %250, %257
%253 = call i32* @getNextLine(i8* %10, i32* %235)
%254 = icmp eq i32* %253, null
br i1 %254, label %255, label %257
255: ; preds = %252
%256 = call i32 @fisError(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.5, i64 0, i64 0))
br label %257
257: ; preds = %255, %252
%258 = call i32 (i8*, i8*, i8*, ...) @sscanf(i8* %10, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.4, i64 0, i64 0), i8* %11)
%259 = icmp eq i32 %258, 1
br i1 %259, label %260, label %252
260: ; preds = %257
%261 = call i64 @strlen(i8* %11)
%262 = trunc i64 %261 to i32
%263 = icmp sgt i32 %262, 0
br i1 %263, label %264, label %278
264: ; preds = %260
%265 = getelementptr inbounds double*, double** %16, i64 %251
%266 = load double*, double** %265
br label %267
267: ; preds = %264, %267
%268 = phi i64 [ 0, %264 ], [ %273, %267 ]
%269 = getelementptr inbounds [500 x i8], [500 x i8]* %5, i64 0, i64 %268
%270 = load i8, i8* %269
%271 = sitofp i8 %270 to double
%272 = getelementptr inbounds double, double* %266, i64 %268
store double %271, double* %272
%273 = add nuw nsw i64 %268, 1
%274 = call i64 @strlen(i8* %11)
%275 = shl i64 %274, 32
%276 = ashr exact i64 %275, 32
%277 = icmp slt i64 %273, %276
br i1 %277, label %267, label %278
278: ; preds = %267, %260
%279 = add nuw nsw i64 %251, 1
%280 = icmp eq i64 %279, %249
br i1 %280, label %281, label %250
281: ; preds = %278, %244
%282 = phi i32 [ 11, %244 ], [ %248, %278 ]
%283 = call i32 @fclose(i32* %235)
%284 = call i32* @fisOpenFile(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
br i1 %246, label %285, label %311
285: ; preds = %281
%286 = zext i32 %282 to i64
br label %287
287: ; preds = %285, %306
%288 = phi i64 [ %286, %285 ], [ %299, %306 ]
%289 = phi i32 [ 0, %285 ], [ %307, %306 ]
br label %290
290: ; preds = %287, %295
%291 = call i32* @getNextLine(i8* %10, i32* %284)
%292 = icmp eq i32* %291, null
br i1 %292, label %293, label %295
293: ; preds = %290
%294 = call i32 @fisError(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.6, i64 0, i64 0))
br label %295
295: ; preds = %293, %290
%296 = call i32 (i8*, i8*, i8*, ...) @sscanf(i8* %10, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.7, i64 0, i64 0), i8* %11)
%297 = icmp eq i32 %296, 1
br i1 %297, label %298, label %290
298: ; preds = %295
%299 = add nuw nsw i64 %288, 1
%300 = getelementptr inbounds double*, double** %16, i64 %288
%301 = load double*, double** %300
%302 = call i32 @getArray(i8* %11, double* %301)
%303 = icmp eq i32 %302, 2
br i1 %303, label %306, label %304
304: ; preds = %298
%305 = call i32 @fisError(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.8, i64 0, i64 0))
br label %306
306: ; preds = %298, %304
%307 = add nuw nsw i32 %289, 1
%308 = icmp eq i32 %307, %245
br i1 %308, label %309, label %287
309: ; preds = %306
%310 = trunc i64 %299 to i32
br label %311
311: ; preds = %309, %281
%312 = phi i32 [ %282, %281 ], [ %310, %309 ]
%313 = call i32 @fclose(i32* %284)
%314 = call i32* @fisOpenFile(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
br i1 %246, label %315, label %371
315: ; preds = %311
%316 = shl i64 %56, 32
%317 = ashr exact i64 %316, 32
%318 = zext i32 %245 to i64
br label %319
319: ; preds = %315, %367
%320 = phi i64 [ 0, %315 ], [ %369, %367 ]
%321 = phi i32 [ %312, %315 ], [ %368, %367 ]
%322 = icmp slt i64 %320, %317
%323 = getelementptr inbounds double, double* %66, i64 %320
%324 = sub nsw i64 %320, %317
%325 = getelementptr inbounds double, double* %69, i64 %324
%326 = select i1 %322, double* %323, double* %325
%327 = load double, double* %326
%328 = fptosi double %327 to i32
%329 = icmp sgt i32 %328, 0
br i1 %329, label %330, label %367
330: ; preds = %319
%331 = sext i32 %321 to i64
br label %332
332: ; preds = %330, %361
%333 = phi i64 [ %331, %330 ], [ %362, %361 ]
%334 = phi i32 [ 0, %330 ], [ %363, %361 ]
br label %335
335: ; preds = %332, %340
%336 = call i32* @getNextLine(i8* %10, i32* %314)
%337 = icmp eq i32* %336, null
br i1 %337, label %338, label %340
338: ; preds = %335
%339 = call i32 @fisError(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.9, i64 0, i64 0))
br label %340
340: ; preds = %338, %335
%341 = call i32 (i8*, i8*, i8*, ...) @sscanf(i8* %10, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.10, i64 0, i64 0), i8* %11, i8* %12, i8* %13, i8* %14)
%342 = icmp eq i32 %341, 4
br i1 %342, label %343, label %335
343: ; preds = %340
%344 = call i64 @strlen(i8* %12)
%345 = trunc i64 %344 to i32
%346 = icmp sgt i32 %345, 0
br i1 %346, label %347, label %361
347: ; preds = %343
%348 = getelementptr inbounds double*, double** %16, i64 %333
%349 = load double*, double** %348
br label %350
350: ; preds = %347, %350
%351 = phi i64 [ 0, %347 ], [ %356, %350 ]
%352 = getelementptr inbounds [500 x i8], [500 x i8]* %6, i64 0, i64 %351
%353 = load i8, i8* %352
%354 = sitofp i8 %353 to double
%355 = getelementptr inbounds double, double* %349, i64 %351
store double %354, double* %355
%356 = add nuw nsw i64 %351, 1
%357 = call i64 @strlen(i8* %12)
%358 = shl i64 %357, 32
%359 = ashr exact i64 %358, 32
%360 = icmp slt i64 %356, %359
br i1 %360, label %350, label %361
361: ; preds = %350, %343
%362 = add nsw i64 %333, 1
%363 = add nuw nsw i32 %334, 1
%364 = icmp eq i32 %363, %328
br i1 %364, label %365, label %332
365: ; preds = %361
%366 = trunc i64 %362 to i32
br label %367
367: ; preds = %365, %319
%368 = phi i32 [ %321, %319 ], [ %366, %365 ]
%369 = add nuw nsw i64 %320, 1
%370 = icmp eq i64 %369, %318
br i1 %370, label %371, label %319
371: ; preds = %367, %311
%372 = phi i32 [ %312, %311 ], [ %368, %367 ]
%373 = call i32 @fclose(i32* %314)
%374 = call i32* @fisOpenFile(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
br i1 %246, label %375, label %431
375: ; preds = %371
%376 = shl i64 %56, 32
%377 = ashr exact i64 %376, 32
%378 = zext i32 %245 to i64
br label %379
379: ; preds = %375, %427
%380 = phi i64 [ 0, %375 ], [ %429, %427 ]
%381 = phi i32 [ %372, %375 ], [ %428, %427 ]
%382 = icmp slt i64 %380, %377
%383 = getelementptr inbounds double, double* %66, i64 %380
%384 = sub nsw i64 %380, %377
%385 = getelementptr inbounds double, double* %69, i64 %384
%386 = select i1 %382, double* %383, double* %385
%387 = load double, double* %386
%388 = fptosi double %387 to i32
%389 = icmp sgt i32 %388, 0
br i1 %389, label %390, label %427
390: ; preds = %379
%391 = sext i32 %381 to i64
br label %392
392: ; preds = %390, %421
%393 = phi i64 [ %391, %390 ], [ %422, %421 ]
%394 = phi i32 [ 0, %390 ], [ %423, %421 ]
br label %395
395: ; preds = %392, %400
%396 = call i32* @getNextLine(i8* %10, i32* %374)
%397 = icmp eq i32* %396, null
br i1 %397, label %398, label %400
398: ; preds = %395
%399 = call i32 @fisError(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.11, i64 0, i64 0))
br label %400
400: ; preds = %398, %395
%401 = call i32 (i8*, i8*, i8*, ...) @sscanf(i8* %10, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.10, i64 0, i64 0), i8* %11, i8* %12, i8* %13, i8* %14)
%402 = icmp eq i32 %401, 4
br i1 %402, label %403, label %395
403: ; preds = %400
%404 = call i64 @strlen(i8* %13)
%405 = trunc i64 %404 to i32
%406 = icmp sgt i32 %405, 0
br i1 %406, label %407, label %421
407: ; preds = %403
%408 = getelementptr inbounds double*, double** %16, i64 %393
%409 = load double*, double** %408
br label %410
410: ; preds = %407, %410
%411 = phi i64 [ 0, %407 ], [ %416, %410 ]
%412 = getelementptr inbounds [500 x i8], [500 x i8]* %7, i64 0, i64 %411
%413 = load i8, i8* %412
%414 = sitofp i8 %413 to double
%415 = getelementptr inbounds double, double* %409, i64 %411
store double %414, double* %415
%416 = add nuw nsw i64 %411, 1
%417 = call i64 @strlen(i8* %13)
%418 = shl i64 %417, 32
%419 = ashr exact i64 %418, 32
%420 = icmp slt i64 %416, %419
br i1 %420, label %410, label %421
421: ; preds = %410, %403
%422 = add nsw i64 %393, 1
%423 = add nuw nsw i32 %394, 1
%424 = icmp eq i32 %423, %388
br i1 %424, label %425, label %392
425: ; preds = %421
%426 = trunc i64 %422 to i32
br label %427
427: ; preds = %425, %379
%428 = phi i32 [ %381, %379 ], [ %426, %425 ]
%429 = add nuw nsw i64 %380, 1
%430 = icmp eq i64 %429, %378
br i1 %430, label %431, label %379
431: ; preds = %427, %371
%432 = phi i32 [ %372, %371 ], [ %428, %427 ]
%433 = call i32 @fclose(i32* %374)
%434 = call i32* @fisOpenFile(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
br i1 %246, label %435, label %512
435: ; preds = %431
%436 = bitcast [500 x i8]* %9 to i64*
%437 = load i64, i64* %436
%438 = icmp eq i64 %437, 29676237130391917
%439 = add nsw i32 %57, 1
%440 = shl i64 %56, 32
%441 = ashr exact i64 %440, 32
%442 = shl i64 %56, 32
%443 = ashr exact i64 %442, 32
%444 = zext i32 %245 to i64
br label %445
445: ; preds = %435, %508
%446 = phi i64 [ 0, %435 ], [ %510, %508 ]
%447 = phi i32 [ %432, %435 ], [ %509, %508 ]
%448 = icmp slt i64 %446, %443
%449 = getelementptr inbounds double, double* %66, i64 %446
%450 = sub nsw i64 %446, %443
%451 = getelementptr inbounds double, double* %69, i64 %450
%452 = select i1 %448, double* %449, double* %451
%453 = load double, double* %452
%454 = fptosi double %453 to i32
%455 = icmp sgt i32 %454, 0
br i1 %455, label %456, label %508
456: ; preds = %445
%457 = sext i32 %447 to i64
br label %458
458: ; preds = %456, %502
%459 = phi i64 [ %457, %456 ], [ %503, %502 ]
%460 = phi i32 [ 0, %456 ], [ %504, %502 ]
br label %461
461: ; preds = %458, %466
%462 = call i32* @getNextLine(i8* %10, i32* %434)
%463 = icmp eq i32* %462, null
br i1 %463, label %464, label %466
464: ; preds = %461
%465 = call i32 @fisError(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.12, i64 0, i64 0))
br label %466
466: ; preds = %464, %461
%467 = call i32 (i8*, i8*, i8*, ...) @sscanf(i8* %10, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.10, i64 0, i64 0), i8* %11, i8* %12, i8* %13, i8* %14)
%468 = icmp eq i32 %467, 4
br i1 %468, label %469, label %461
469: ; preds = %466
%470 = getelementptr inbounds double*, double** %16, i64 %459
%471 = load double*, double** %470
%472 = call i32 @getArray(i8* %14, double* %471)
br i1 %448, label %473, label %477
473: ; preds = %469
%474 = icmp sgt i32 %472, 4
br i1 %474, label %475, label %502
475: ; preds = %473
%476 = call i32 @fisError(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.13, i64 0, i64 0))
br label %502
477: ; preds = %469
br i1 %438, label %478, label %482
478: ; preds = %477
%479 = icmp sgt i32 %472, 4
br i1 %479, label %480, label %502
480: ; preds = %478
%481 = call i32 @fisError(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.15, i64 0, i64 0))
br label %502
482: ; preds = %477
%483 = call i32 @bcmp(i8* dereferenceable(9) %13, i8* dereferenceable(9) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.16, i64 0, i64 0), i64 9)
%484 = icmp eq i32 %483, 0
br i1 %484, label %485, label %493
485: ; preds = %482
%486 = icmp eq i32 %472, 1
br i1 %486, label %489, label %487
487: ; preds = %485
%488 = call i32 @fisError(i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.17, i64 0, i64 0))
br label %502
489: ; preds = %485
%490 = load double*, double** %470
%491 = load double, double* %490
%492 = getelementptr inbounds double, double* %490, i64 %441
store double %491, double* %492
store double 0.000000e+00, double* %490
br label %502
493: ; preds = %482
%494 = call i32 @bcmp(i8* dereferenceable(7) %13, i8* dereferenceable(7) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.18, i64 0, i64 0), i64 7)
%495 = icmp eq i32 %494, 0
br i1 %495, label %496, label %500
496: ; preds = %493
%497 = icmp eq i32 %472, %439
br i1 %497, label %502, label %498
498: ; preds = %496
%499 = call i32 @fisError(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.19, i64 0, i64 0))
br label %502
500: ; preds = %493
%501 = call i32 @fisError(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.20, i64 0, i64 0))
br label %502
502: ; preds = %489, %487, %496, %498, %500, %480, %478, %473, %475
%503 = add nsw i64 %459, 1
%504 = add nuw nsw i32 %460, 1
%505 = icmp eq i32 %504, %454
br i1 %505, label %506, label %458
506: ; preds = %502
%507 = trunc i64 %503 to i32
br label %508
508: ; preds = %506, %445
%509 = phi i32 [ %447, %445 ], [ %507, %506 ]
%510 = add nuw nsw i64 %446, 1
%511 = icmp eq i64 %510, %444
br i1 %511, label %512, label %445
512: ; preds = %508, %431
%513 = phi i32 [ %432, %431 ], [ %509, %508 ]
%514 = call i32 @fclose(i32* %434)
%515 = call i32* @fisOpenFile(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%516 = bitcast [500 x i8]* %4 to i64*
br label %517
517: ; preds = %522, %512
%518 = call i32* @getNextLine(i8* %10, i32* %515)
%519 = icmp eq i32* %518, null
br i1 %519, label %520, label %522
520: ; preds = %517
%521 = call i32 @fisError(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.21, i64 0, i64 0))
br label %522
522: ; preds = %520, %517
%523 = load i64, i64* %516
%524 = icmp eq i64 %523, 26304052282610267
br i1 %524, label %525, label %517
525: ; preds = %522
%526 = icmp sgt i32 %215, 0
br i1 %526, label %527, label %563
527: ; preds = %525
%528 = add nsw i32 %245, 2
%529 = sext i32 %513 to i64
br label %530
530: ; preds = %527, %560
%531 = phi i64 [ %529, %527 ], [ %553, %560 ]
%532 = phi i32 [ 0, %527 ], [ %561, %560 ]
%533 = call i32* @getNextLine(i8* %10, i32* %515)
%534 = icmp eq i32* %533, null
br i1 %534, label %535, label %537
535: ; preds = %530
%536 = call i32 @fisError(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.23, i64 0, i64 0))
br label %537
537: ; preds = %535, %530
%538 = call i64 @strlen(i8* %10)
%539 = trunc i64 %538 to i32
%540 = icmp sgt i32 %539, 0
br i1 %540, label %541, label %552
541: ; preds = %537, %546
%542 = phi i64 [ %547, %546 ], [ 0, %537 ]
%543 = getelementptr inbounds [500 x i8], [500 x i8]* %4, i64 0, i64 %542
%544 = load i8, i8* %543
switch i8 %544, label %546 [
i8 44, label %545
i8 40, label %545
i8 41, label %545
i8 58, label %545
]
545: ; preds = %541, %541, %541, %541
store i8 32, i8* %543
br label %546
546: ; preds = %541, %545
%547 = add nuw nsw i64 %542, 1
%548 = call i64 @strlen(i8* %10)
%549 = shl i64 %548, 32
%550 = ashr exact i64 %549, 32
%551 = icmp slt i64 %547, %550
br i1 %551, label %541, label %552
552: ; preds = %546, %537
%553 = add nsw i64 %531, 1
%554 = getelementptr inbounds double*, double** %16, i64 %531
%555 = load double*, double** %554
%556 = call i32 @getArray(i8* %10, double* %555)
%557 = icmp eq i32 %556, %528
br i1 %557, label %560, label %558
558: ; preds = %552
%559 = call i32 @fisError(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.24, i64 0, i64 0))
br label %560
560: ; preds = %552, %558
%561 = add nuw nsw i32 %532, 1
%562 = icmp eq i32 %561, %215
br i1 %562, label %563, label %530
563: ; preds = %560, %525
%564 = call i32 @fclose(i32* %515)
%565 = call i32 @free(double* %66)
%566 = call i32 @free(double* %69)
ret double** %16
}