#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*/ *);
int /*<<< orphan*/ feof(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fscanf(int /*<<< orphan*/ *, char *, ...);
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ readMatrix(double **, int /*<<< orphan*/ *);
int /*<<< orphan*/ readMatrix2(double **, int /*<<< orphan*/ *);
scalar_t__ strcmp(char *, char *);
void readDba(double dataDba[], double steadyStateCoefficients[][126],
             double XForceDerivatives[][126], double YForceDerivatives[][126],
             double ZForceDerivatives[][126],
             double RollingMomentDerivatives[][126],
             double PitchingMomentDerivatives[][126],
             double YawingMomentDerivatives[][126],
             double ControlForceDerivatives[][126],
             double ControlMomentDerivatives[][126],
             double RotaryDerivatives[][126]) {
  double mass;
  double wingspan;
  double surface;
  double chord;
  double MachDragRaise;
  double Jx;
  double Jy;
  double Jz;
  double Jxz;
  double minElevators;
  double maxElevators;
  double ailerons;
  double rudder;
  double minFlaps;
  double maxFlaps;
  double fuelFraction;
  char c;
  char tokenPtr[300] = {0};
  int count = 0;
  int i;
  FILE *fPtr;
  if ((fPtr = fopen("dba.txt", "r")) == NULL) {
    printf("File could not be opened\n");
  } else {
    fscanf(fPtr, "%c", &c);
    while (!feof(fPtr)) {
      if ((c != ' ') && (c != '\t') && (c != '\n')) {
        tokenPtr[count] = c;
        count++;
      } else if (count != 0) {
        tokenPtr[count] = '\0';
        count = 0;
        if (strcmp(tokenPtr, "VELIVOLO") == 0) {
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%lg", &mass);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%lg", &wingspan);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%lg", &surface);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%lg", &chord);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%lg", &MachDragRaise);
        } else if (strcmp(tokenPtr, "LOCATION") == 0) {
          fscanf(fPtr, "%lg", &Jx);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%lg", &Jy);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%lg", &Jz);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%lg", &Jxz);
          for (i = 0; i < 39; i++)
            fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%lg", &maxElevators);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%lg", &minElevators);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%lg", &ailerons);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%lg", &rudder);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%lg", &minFlaps);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%lg", &maxFlaps);
          for (i = 0; i < 13; i++)
            fscanf(fPtr, "%s", tokenPtr);
          fscanf(fPtr, "%lg", &fuelFraction);
        } else if (strcmp(tokenPtr, "Cm") == 0) {
          fscanf(fPtr, "%s", tokenPtr);
          readMatrix(steadyStateCoefficients, fPtr);
        } else if (strcmp(tokenPtr, "CXP") == 0) {
          fscanf(fPtr, "%s", tokenPtr);
          readMatrix2(XForceDerivatives, fPtr);
        } else if (strcmp(tokenPtr, "CYA") == 0) {
          fscanf(fPtr, "%s", tokenPtr);
          readMatrix(YForceDerivatives, fPtr);
        } else if (strcmp(tokenPtr, "CZP") == 0) {
          fscanf(fPtr, "%s", tokenPtr);
          readMatrix2(ZForceDerivatives, fPtr);
        } else if (strcmp(tokenPtr, "ClA") == 0) {
          fscanf(fPtr, "%s", tokenPtr);
          readMatrix(RollingMomentDerivatives, fPtr);
        } else if (strcmp(tokenPtr, "CmP") == 0) {
          fscanf(fPtr, "%s", tokenPtr);
          readMatrix2(PitchingMomentDerivatives, fPtr);
        } else if (strcmp(tokenPtr, "CnA") == 0) {
          fscanf(fPtr, "%s", tokenPtr);
          readMatrix(YawingMomentDerivatives, fPtr);
        } else if (strcmp(tokenPtr, "CYda") == 0) {
          fscanf(fPtr, "%s", tokenPtr);
          readMatrix(ControlForceDerivatives, fPtr);
        } else if (strcmp(tokenPtr, "Cnda") == 0) {
          fscanf(fPtr, "%s", tokenPtr);
          readMatrix(ControlMomentDerivatives, fPtr);
        } else if (strcmp(tokenPtr, "Cmom") == 0) {
          fscanf(fPtr, "%s", tokenPtr);
          readMatrix(RotaryDerivatives, fPtr);
        }
      }
      fscanf(fPtr, "%c", &c);
    }
    fclose(fPtr);
    dataDba[0] = mass;
    dataDba[1] = wingspan;
    dataDba[2] = surface;
    dataDba[3] = chord;
    dataDba[4] = MachDragRaise;
    dataDba[5] = Jx;
    dataDba[6] = Jy;
    dataDba[7] = Jz;
    dataDba[8] = Jxz;
    dataDba[9] = minElevators;
    dataDba[10] = maxElevators;
    dataDba[11] = ailerons;
    dataDba[12] = rudder;
    dataDba[13] = minFlaps;
    dataDba[14] = maxFlaps;
    dataDba[15] = fuelFraction;
  }
}


x86 assembly (clang, -O0):
<readDba>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1f0,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
lea    -0x1e0(%rbp),%rdi
xor    %esi,%esi
mov    $0x12c,%edx
call   1070 <memset@plt>
movl   $0x0,-0x1e4(%rbp)
lea    0xe15(%rip),%rdi
lea    0xe16(%rip),%rsi
call   10b0 <fopen@plt>
mov    %rax,-0x1f0(%rbp)
cmp    $0x0,%rax
jne    1219 <readDba+0x89>
lea    0xdfb(%rip),%rdi
call   1060 <printf@plt>
jmp    1c32 <readDba+0xaa2>
mov    -0x1f0(%rbp),%rdi
lea    0xdfd(%rip),%rsi
lea    -0xb1(%rbp),%rdx
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
call   10a0 <feof@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1256 <readDba+0xc6>
jmp    1b35 <readDba+0x9a5>
movsbl -0xb1(%rbp),%eax
cmp    $0x20,%eax
je     12ae <readDba+0x11e>
movsbl -0xb1(%rbp),%eax
cmp    $0x9,%eax
je     12ae <readDba+0x11e>
movsbl -0xb1(%rbp),%eax
cmp    $0xa,%eax
je     12ae <readDba+0x11e>
mov    -0xb1(%rbp),%cl
movslq -0x1e4(%rbp),%rax
mov    %cl,-0x1e0(%rbp,%rax,1)
mov    -0x1e4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1e4(%rbp)
jmp    1b14 <readDba+0x984>
cmpl   $0x0,-0x1e4(%rbp)
je     1b0f <readDba+0x97f>
movslq -0x1e4(%rbp),%rax
movb   $0x0,-0x1e0(%rbp,%rax,1)
movl   $0x0,-0x1e4(%rbp)
lea    -0x1e0(%rbp),%rdi
lea    0xd45(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%rax
jne    146f <readDba+0x2df>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0xd2a(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0xd0e(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0xcf2(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    0xce0(%rip),%rsi
lea    -0x38(%rbp),%rdx
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0xcbd(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    0xcab(%rip),%rsi
lea    -0x40(%rbp),%rdx
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0xc88(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0xc6c(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    0xc5a(%rip),%rsi
lea    -0x48(%rbp),%rdx
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0xc37(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0xc1b(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    0xc09(%rip),%rsi
lea    -0x50(%rbp),%rdx
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0xbe6(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    0xbd4(%rip),%rsi
lea    -0x58(%rbp),%rdx
mov    $0x0,%al
call   1080 <fscanf@plt>
jmp    1b0a <readDba+0x97a>
lea    -0x1e0(%rbp),%rdi
lea    0xbba(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%rax
jne    17cc <readDba+0x63c>
mov    -0x1f0(%rbp),%rdi
lea    0xb99(%rip),%rsi
lea    -0x60(%rbp),%rdx
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0xb76(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    0xb64(%rip),%rsi
lea    -0x68(%rbp),%rdx
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0xb41(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    0xb2f(%rip),%rsi
lea    -0x70(%rbp),%rdx
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0xb0c(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    0xafa(%rip),%rsi
lea    -0x78(%rbp),%rdx
mov    $0x0,%al
call   1080 <fscanf@plt>
movl   $0x0,-0x1e8(%rbp)
cmpl   $0x27,-0x1e8(%rbp)
jge    158b <readDba+0x3fb>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0xac0(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1e8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1e8(%rbp)
jmp    154e <readDba+0x3be>
mov    -0x1f0(%rbp),%rdi
lea    0xa9a(%rip),%rsi
lea    -0x88(%rbp),%rdx
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0xa74(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0xa58(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    0xa46(%rip),%rsi
lea    -0x80(%rbp),%rdx
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0xa23(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0xa07(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    0x9f5(%rip),%rsi
lea    -0x90(%rbp),%rdx
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0x9cf(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0x9b3(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    0x9a1(%rip),%rsi
lea    -0x98(%rbp),%rdx
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0x97b(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0x95f(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    0x94d(%rip),%rsi
lea    -0xa0(%rbp),%rdx
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0x927(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0x90b(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0x8ef(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1f0(%rbp),%rdi
lea    0x8dd(%rip),%rsi
lea    -0xa8(%rbp),%rdx
mov    $0x0,%al
call   1080 <fscanf@plt>
movl   $0x0,-0x1e8(%rbp)
cmpl   $0xd,-0x1e8(%rbp)
jge    17ab <readDba+0x61b>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0x8a0(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x1e8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1e8(%rbp)
jmp    176e <readDba+0x5de>
mov    -0x1f0(%rbp),%rdi
lea    0x87a(%rip),%rsi
lea    -0xb0(%rbp),%rdx
mov    $0x0,%al
call   1080 <fscanf@plt>
jmp    1b05 <readDba+0x975>
lea    -0x1e0(%rbp),%rdi
lea    0x866(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%rax
jne    181a <readDba+0x68a>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0x832(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x10(%rbp),%rdi
mov    -0x1f0(%rbp),%rsi
call   1030 <readMatrix@plt>
jmp    1b00 <readDba+0x970>
lea    -0x1e0(%rbp),%rdi
lea    0x81b(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%rax
jne    1868 <readDba+0x6d8>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0x7e4(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x18(%rbp),%rdi
mov    -0x1f0(%rbp),%rsi
call   1040 <readMatrix2@plt>
jmp    1afb <readDba+0x96b>
lea    -0x1e0(%rbp),%rdi
lea    0x7d1(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%rax
jne    18b6 <readDba+0x726>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0x796(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x20(%rbp),%rdi
mov    -0x1f0(%rbp),%rsi
call   1030 <readMatrix@plt>
jmp    1af6 <readDba+0x966>
lea    -0x1e0(%rbp),%rdi
lea    0x787(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%rax
jne    1904 <readDba+0x774>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0x748(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x28(%rbp),%rdi
mov    -0x1f0(%rbp),%rsi
call   1040 <readMatrix2@plt>
jmp    1af1 <readDba+0x961>
lea    -0x1e0(%rbp),%rdi
lea    0x73d(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%rax
jne    1952 <readDba+0x7c2>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0x6fa(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    -0x30(%rbp),%rdi
mov    -0x1f0(%rbp),%rsi
call   1030 <readMatrix@plt>
jmp    1aec <readDba+0x95c>
lea    -0x1e0(%rbp),%rdi
lea    0x6f3(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%rax
jne    19a0 <readDba+0x810>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0x6ac(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    0x10(%rbp),%rdi
mov    -0x1f0(%rbp),%rsi
call   1040 <readMatrix2@plt>
jmp    1ae7 <readDba+0x957>
lea    -0x1e0(%rbp),%rdi
lea    0x6a9(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%rax
jne    19ee <readDba+0x85e>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0x65e(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    0x18(%rbp),%rdi
mov    -0x1f0(%rbp),%rsi
call   1030 <readMatrix@plt>
jmp    1ae2 <readDba+0x952>
lea    -0x1e0(%rbp),%rdi
lea    0x65f(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%rax
jne    1a3c <readDba+0x8ac>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0x610(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    0x20(%rbp),%rdi
mov    -0x1f0(%rbp),%rsi
call   1030 <readMatrix@plt>
jmp    1add <readDba+0x94d>
lea    -0x1e0(%rbp),%rdi
lea    0x616(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%rax
jne    1a8a <readDba+0x8fa>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0x5c2(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    0x28(%rbp),%rdi
mov    -0x1f0(%rbp),%rsi
call   1030 <readMatrix@plt>
jmp    1ad8 <readDba+0x948>
lea    -0x1e0(%rbp),%rdi
lea    0x5cd(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%rax
jne    1ad3 <readDba+0x943>
mov    -0x1f0(%rbp),%rdi
lea    -0x1e0(%rbp),%rdx
lea    0x574(%rip),%rsi
mov    $0x0,%al
call   1080 <fscanf@plt>
mov    0x30(%rbp),%rdi
mov    -0x1f0(%rbp),%rsi
call   1030 <readMatrix@plt>
jmp    1ad8 <readDba+0x948>
jmp    1add <readDba+0x94d>
jmp    1ae2 <readDba+0x952>
jmp    1ae7 <readDba+0x957>
jmp    1aec <readDba+0x95c>
jmp    1af1 <readDba+0x961>
jmp    1af6 <readDba+0x966>
jmp    1afb <readDba+0x96b>
jmp    1b00 <readDba+0x970>
jmp    1b05 <readDba+0x975>
jmp    1b0a <readDba+0x97a>
jmp    1b0f <readDba+0x97f>
jmp    1b14 <readDba+0x984>
mov    -0x1f0(%rbp),%rdi
lea    0x502(%rip),%rsi
lea    -0xb1(%rbp),%rdx
mov    $0x0,%al
call   1080 <fscanf@plt>
jmp    1235 <readDba+0xa5>
mov    -0x1f0(%rbp),%rdi
call   1050 <fclose@plt>
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0x70(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x38(%rax)
movsd  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x40(%rax)
movsd  -0x80(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x48(%rax)
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x50(%rax)
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x58(%rax)
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x60(%rax)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x68(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x70(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x78(%rax)
add    $0x1f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<readDba>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x218,%rsp
mov    %r9,%r12
mov    %r8,%r13
mov    %rcx,%rbx
mov    %rdx,%rbp
mov    %rsi,0x50(%rsp)
mov    %rdi,0x58(%rsp)
mov    0x270(%rsp),%rax
mov    %rax,0x28(%rsp)
mov    0x268(%rsp),%rax
mov    %rax,0x30(%rsp)
mov    0x260(%rsp),%rax
mov    %rax,0x38(%rsp)
mov    0x258(%rsp),%rax
mov    %rax,0x40(%rsp)
mov    0x250(%rsp),%rax
mov    %rax,0x48(%rsp)
lea    0xe0(%rsp),%rdi
mov    $0x12c,%edx
xor    %esi,%esi
call   1070 <memset@plt>
lea    0xded(%rip),%rdi
lea    0xdee(%rip),%rsi
call   10b0 <fopen@plt>
test   %rax,%rax
je     1357 <readDba+0x1c7>
mov    %rax,%r14
mov    %rbp,0x20(%rsp)
mov    %rbx,0x18(%rsp)
mov    %r13,0x10(%rsp)
mov    %r12,0x8(%rsp)
lea    0xdc4(%rip),%rsi
lea    0x7(%rsp),%rdx
mov    %rax,%rdi
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
call   10a0 <feof@plt>
test   %eax,%eax
je     1374 <readDba+0x1e4>
mov    %r14,%rdi
call   1060 <fclose@plt>
movsd  0xd8(%rsp),%xmm0
mov    0x58(%rsp),%rax
movsd  %xmm0,(%rax)
movsd  0xd0(%rsp),%xmm0
movsd  %xmm0,0x8(%rax)
movsd  0xc8(%rsp),%xmm0
movsd  %xmm0,0x10(%rax)
movsd  0xc0(%rsp),%xmm0
movsd  %xmm0,0x18(%rax)
movsd  0xb8(%rsp),%xmm0
movsd  %xmm0,0x20(%rax)
movsd  0xb0(%rsp),%xmm0
movsd  %xmm0,0x28(%rax)
movsd  0xa8(%rsp),%xmm0
movsd  %xmm0,0x30(%rax)
movsd  0xa0(%rsp),%xmm0
movsd  %xmm0,0x38(%rax)
movsd  0x98(%rsp),%xmm0
movsd  %xmm0,0x40(%rax)
movsd  0x90(%rsp),%xmm0
movsd  %xmm0,0x48(%rax)
movsd  0x88(%rsp),%xmm0
movsd  %xmm0,0x50(%rax)
movsd  0x80(%rsp),%xmm0
movsd  %xmm0,0x58(%rax)
movsd  0x78(%rsp),%xmm0
movsd  %xmm0,0x60(%rax)
movsd  0x70(%rsp),%xmm0
movsd  %xmm0,0x68(%rax)
movsd  0x68(%rsp),%xmm0
movsd  %xmm0,0x70(%rax)
movsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x78(%rax)
add    $0x218,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xcf2(%rip),%rdi
add    $0x218,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <puts@plt>
lea    0xc8f(%rip),%rbx
lea    0xe0(%rsp),%rbp
lea    0xc8c(%rip),%r13
xor    %ecx,%ecx
jmp    13c5 <readDba+0x235>
xchg   %ax,%ax
movslq %ecx,%rdx
mov    %al,0xe0(%rsp,%rdx,1)
add    $0x1,%ecx
mov    %ecx,%r12d
mov    %r14,%rdi
mov    %rbx,%rsi
lea    0x7(%rsp),%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
call   10a0 <feof@plt>
mov    %r12d,%ecx
test   %eax,%eax
jne    1265 <readDba+0xd5>
movzbl 0x7(%rsp),%eax
cmp    $0x20,%rax
ja     1390 <readDba+0x200>
movabs $0x100000600,%rdx
bt     %rax,%rdx
jae    1390 <readDba+0x200>
xor    %r12d,%r12d
test   %ecx,%ecx
je     13a0 <readDba+0x210>
movslq %ecx,%rax
movb   $0x0,0xe0(%rsp,%rax,1)
mov    %rbp,%rdi
lea    0xc11(%rip),%rsi
call   1090 <strcmp@plt>
test   %rax,%rax
je     152f <readDba+0x39f>
mov    %rbp,%rdi
lea    0xc09(%rip),%rsi
call   1090 <strcmp@plt>
test   %rax,%rax
je     1637 <readDba+0x4a7>
mov    %rbp,%rdi
lea    0xbfa(%rip),%rsi
call   1090 <strcmp@plt>
test   %rax,%rax
je     1902 <readDba+0x772>
mov    %rbp,%rdi
lea    0xbe5(%rip),%rsi
call   1090 <strcmp@plt>
test   %rax,%rax
je     191f <readDba+0x78f>
mov    %rbp,%rdi
lea    0xbd1(%rip),%rsi
call   1090 <strcmp@plt>
test   %rax,%rax
je     1939 <readDba+0x7a9>
mov    %rbp,%rdi
lea    0xbbd(%rip),%rsi
call   1090 <strcmp@plt>
test   %rax,%rax
je     1956 <readDba+0x7c6>
mov    %rbp,%rdi
lea    0xba9(%rip),%rsi
call   1090 <strcmp@plt>
test   %rax,%rax
je     1970 <readDba+0x7e0>
mov    %rbp,%rdi
lea    0xb95(%rip),%rsi
call   1090 <strcmp@plt>
test   %rax,%rax
je     198a <readDba+0x7fa>
mov    %rbp,%rdi
lea    0xb81(%rip),%rsi
call   1090 <strcmp@plt>
test   %rax,%rax
je     19af <readDba+0x81f>
mov    %rbp,%rdi
lea    0xb6d(%rip),%rsi
call   1090 <strcmp@plt>
test   %rax,%rax
je     19c9 <readDba+0x839>
mov    %rbp,%rdi
lea    0xb5a(%rip),%rsi
call   1090 <strcmp@plt>
test   %rax,%rax
je     19e3 <readDba+0x853>
mov    %rbp,%rdi
lea    0xb47(%rip),%rsi
call   1090 <strcmp@plt>
test   %rax,%rax
jne    13a0 <readDba+0x210>
xor    %r12d,%r12d
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    0x28(%rsp),%rdi
jmp    19fb <readDba+0x86b>
xor    %r12d,%r12d
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
lea    0xaad(%rip),%r15
mov    %r15,%rsi
lea    0xd8(%rsp),%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r15,%rsi
lea    0xd0(%rsp),%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r15,%rsi
lea    0xc8(%rsp),%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r15,%rsi
lea    0xc0(%rsp),%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r15,%rsi
lea    0xb8(%rsp),%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
jmp    13a0 <readDba+0x210>
mov    %r14,%rdi
lea    0x9d8(%rip),%rbx
mov    %rbx,%rsi
lea    0xb0(%rsp),%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
lea    0xa8(%rsp),%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
lea    0xa0(%rsp),%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
lea    0x98(%rsp),%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    $0x27,%ebx
nopw   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
add    $0xffffffff,%ebx
jne    16d0 <readDba+0x540>
xor    %r12d,%r12d
mov    %r14,%rdi
lea    0x927(%rip),%rbx
mov    %rbx,%rsi
lea    0x88(%rsp),%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
lea    0x90(%rsp),%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
lea    0x80(%rsp),%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
lea    0x78(%rsp),%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
lea    0x70(%rsp),%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
lea    0x68(%rsp),%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
lea    0x60(%rsp),%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
lea    0x70d(%rip),%rbx
jmp    13a0 <readDba+0x210>
xor    %r12d,%r12d
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    0x50(%rsp),%rdi
jmp    19fb <readDba+0x86b>
xor    %r12d,%r12d
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    0x20(%rsp),%rdi
jmp    19a2 <readDba+0x812>
xor    %r12d,%r12d
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    0x18(%rsp),%rdi
jmp    19fb <readDba+0x86b>
xor    %r12d,%r12d
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    0x10(%rsp),%rdi
jmp    19a2 <readDba+0x812>
xor    %r12d,%r12d
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    0x8(%rsp),%rdi
jmp    19fb <readDba+0x86b>
xor    %r12d,%r12d
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    0x48(%rsp),%rdi
mov    %r14,%rsi
call   1050 <readMatrix2@plt>
jmp    13a0 <readDba+0x210>
xor    %r12d,%r12d
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    0x40(%rsp),%rdi
jmp    19fb <readDba+0x86b>
xor    %r12d,%r12d
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    0x38(%rsp),%rdi
jmp    19fb <readDba+0x86b>
xor    %r12d,%r12d
mov    %r14,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    0x30(%rsp),%rdi
mov    %r14,%rsi
call   1030 <readMatrix@plt>
jmp    13a0 <readDba+0x210>

LLVM IR (-O0):
@.str = [8 x i8] c"dba.txt\00"
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [26 x i8] c"File could not be opened\0A\00"
@.str.3 = [3 x i8] c"%c\00"
@.str.4 = [9 x i8] c"VELIVOLO\00"
@.str.5 = [3 x i8] c"%s\00"
@.str.6 = [4 x i8] c"%lg\00"
@.str.7 = [9 x i8] c"LOCATION\00"
@.str.8 = [3 x i8] c"Cm\00"
@.str.9 = [4 x i8] c"CXP\00"
@.str.10 = [4 x i8] c"CYA\00"
@.str.11 = [4 x i8] c"CZP\00"
@.str.12 = [4 x i8] c"ClA\00"
@.str.13 = [4 x i8] c"CmP\00"
@.str.14 = [4 x i8] c"CnA\00"
@.str.15 = [5 x i8] c"CYda\00"
@.str.16 = [5 x i8] c"Cnda\00"
@.str.17 = [5 x i8] c"Cmom\00"
define void @readDba(double* %0, [126 x double]* %1, [126 x double]* %2, [126 x double]* %3, [126 x double]* %4, [126 x double]* %5, [126 x double]* %6, [126 x double]* %7, [126 x double]* %8, [126 x double]* %9, [126 x double]* %10) {
%12 = alloca double*
%13 = alloca [126 x double]*
%14 = alloca [126 x double]*
%15 = alloca [126 x double]*
%16 = alloca [126 x double]*
%17 = alloca [126 x double]*
%18 = alloca [126 x double]*
%19 = alloca [126 x double]*
%20 = alloca [126 x double]*
%21 = alloca [126 x double]*
%22 = alloca [126 x double]*
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
%31 = alloca double
%32 = alloca double
%33 = alloca double
%34 = alloca double
%35 = alloca double
%36 = alloca double
%37 = alloca double
%38 = alloca double
%39 = alloca i8
%40 = alloca [300 x i8]
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32*
store double* %0, double** %12
store [126 x double]* %1, [126 x double]** %13
store [126 x double]* %2, [126 x double]** %14
store [126 x double]* %3, [126 x double]** %15
store [126 x double]* %4, [126 x double]** %16
store [126 x double]* %5, [126 x double]** %17
store [126 x double]* %6, [126 x double]** %18
store [126 x double]* %7, [126 x double]** %19
store [126 x double]* %8, [126 x double]** %20
store [126 x double]* %9, [126 x double]** %21
store [126 x double]* %10, [126 x double]** %22
%44 = bitcast [300 x i8]* %40 to i8*
store i32 0, i32* %41
%45 = call i32* @fopen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32* %45, i32** %43
%46 = icmp eq i32* %45, null
br i1 %46, label %47, label %49
47: ; preds = %11
%48 = call i32 @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0))
br label %402
49: ; preds = %11
%50 = load i32*, i32** %43
%51 = call i32 (i32*, i8*, ...) @fscanf(i32* %50, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* %39)
br label %52
52: ; preds = %348, %49
%53 = load i32*, i32** %43
%54 = call i32 @feof(i32* %53)
%55 = icmp ne i32 %54, 0
%56 = xor i1 %55, true
br i1 %56, label %57, label %351
57: ; preds = %52
%58 = load i8, i8* %39
%59 = sext i8 %58 to i32
%60 = icmp ne i32 %59, 32
br i1 %60, label %61, label %76
61: ; preds = %57
%62 = load i8, i8* %39
%63 = sext i8 %62 to i32
%64 = icmp ne i32 %63, 9
br i1 %64, label %65, label %76
65: ; preds = %61
%66 = load i8, i8* %39
%67 = sext i8 %66 to i32
%68 = icmp ne i32 %67, 10
br i1 %68, label %69, label %76
69: ; preds = %65
%70 = load i8, i8* %39
%71 = load i32, i32* %41
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 %72
store i8 %70, i8* %73
%74 = load i32, i32* %41
%75 = add nsw i32 %74, 1
store i32 %75, i32* %41
br label %348
76: ; preds = %65, %61, %57
%77 = load i32, i32* %41
%78 = icmp ne i32 %77, 0
br i1 %78, label %79, label %347
79: ; preds = %76
%80 = load i32, i32* %41
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 %81
store i8 0, i8* %82
store i32 0, i32* %41
%83 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%84 = call i64 @strcmp(i8* %83, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.4, i64 0, i64 0))
%85 = icmp eq i64 %84, 0
br i1 %85, label %86, label %124
86: ; preds = %79
%87 = load i32*, i32** %43
%88 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%89 = call i32 (i32*, i8*, ...) @fscanf(i32* %87, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %88)
%90 = load i32*, i32** %43
%91 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%92 = call i32 (i32*, i8*, ...) @fscanf(i32* %90, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %91)
%93 = load i32*, i32** %43
%94 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%95 = call i32 (i32*, i8*, ...) @fscanf(i32* %93, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %94)
%96 = load i32*, i32** %43
%97 = call i32 (i32*, i8*, ...) @fscanf(i32* %96, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %23)
%98 = load i32*, i32** %43
%99 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%100 = call i32 (i32*, i8*, ...) @fscanf(i32* %98, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %99)
%101 = load i32*, i32** %43
%102 = call i32 (i32*, i8*, ...) @fscanf(i32* %101, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %24)
%103 = load i32*, i32** %43
%104 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%105 = call i32 (i32*, i8*, ...) @fscanf(i32* %103, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %104)
%106 = load i32*, i32** %43
%107 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%108 = call i32 (i32*, i8*, ...) @fscanf(i32* %106, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %107)
%109 = load i32*, i32** %43
%110 = call i32 (i32*, i8*, ...) @fscanf(i32* %109, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %25)
%111 = load i32*, i32** %43
%112 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%113 = call i32 (i32*, i8*, ...) @fscanf(i32* %111, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %112)
%114 = load i32*, i32** %43
%115 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%116 = call i32 (i32*, i8*, ...) @fscanf(i32* %114, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %115)
%117 = load i32*, i32** %43
%118 = call i32 (i32*, i8*, ...) @fscanf(i32* %117, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %26)
%119 = load i32*, i32** %43
%120 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%121 = call i32 (i32*, i8*, ...) @fscanf(i32* %119, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %120)
%122 = load i32*, i32** %43
%123 = call i32 (i32*, i8*, ...) @fscanf(i32* %122, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %27)
br label %346
124: ; preds = %79
%125 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%126 = call i64 @strcmp(i8* %125, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.7, i64 0, i64 0))
%127 = icmp eq i64 %126, 0
br i1 %127, label %128, label %215
128: ; preds = %124
%129 = load i32*, i32** %43
%130 = call i32 (i32*, i8*, ...) @fscanf(i32* %129, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %28)
%131 = load i32*, i32** %43
%132 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%133 = call i32 (i32*, i8*, ...) @fscanf(i32* %131, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %132)
%134 = load i32*, i32** %43
%135 = call i32 (i32*, i8*, ...) @fscanf(i32* %134, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %29)
%136 = load i32*, i32** %43
%137 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%138 = call i32 (i32*, i8*, ...) @fscanf(i32* %136, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %137)
%139 = load i32*, i32** %43
%140 = call i32 (i32*, i8*, ...) @fscanf(i32* %139, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %30)
%141 = load i32*, i32** %43
%142 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%143 = call i32 (i32*, i8*, ...) @fscanf(i32* %141, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %142)
%144 = load i32*, i32** %43
%145 = call i32 (i32*, i8*, ...) @fscanf(i32* %144, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %31)
store i32 0, i32* %42
br label %146
146: ; preds = %153, %128
%147 = load i32, i32* %42
%148 = icmp slt i32 %147, 39
br i1 %148, label %149, label %156
149: ; preds = %146
%150 = load i32*, i32** %43
%151 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%152 = call i32 (i32*, i8*, ...) @fscanf(i32* %150, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %151)
br label %153
153: ; preds = %149
%154 = load i32, i32* %42
%155 = add nsw i32 %154, 1
store i32 %155, i32* %42
br label %146
156: ; preds = %146
%157 = load i32*, i32** %43
%158 = call i32 (i32*, i8*, ...) @fscanf(i32* %157, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %33)
%159 = load i32*, i32** %43
%160 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%161 = call i32 (i32*, i8*, ...) @fscanf(i32* %159, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %160)
%162 = load i32*, i32** %43
%163 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%164 = call i32 (i32*, i8*, ...) @fscanf(i32* %162, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %163)
%165 = load i32*, i32** %43
%166 = call i32 (i32*, i8*, ...) @fscanf(i32* %165, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %32)
%167 = load i32*, i32** %43
%168 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%169 = call i32 (i32*, i8*, ...) @fscanf(i32* %167, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %168)
%170 = load i32*, i32** %43
%171 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%172 = call i32 (i32*, i8*, ...) @fscanf(i32* %170, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %171)
%173 = load i32*, i32** %43
%174 = call i32 (i32*, i8*, ...) @fscanf(i32* %173, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %34)
%175 = load i32*, i32** %43
%176 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%177 = call i32 (i32*, i8*, ...) @fscanf(i32* %175, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %176)
%178 = load i32*, i32** %43
%179 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%180 = call i32 (i32*, i8*, ...) @fscanf(i32* %178, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %179)
%181 = load i32*, i32** %43
%182 = call i32 (i32*, i8*, ...) @fscanf(i32* %181, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %35)
%183 = load i32*, i32** %43
%184 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%185 = call i32 (i32*, i8*, ...) @fscanf(i32* %183, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %184)
%186 = load i32*, i32** %43
%187 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%188 = call i32 (i32*, i8*, ...) @fscanf(i32* %186, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %187)
%189 = load i32*, i32** %43
%190 = call i32 (i32*, i8*, ...) @fscanf(i32* %189, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %36)
%191 = load i32*, i32** %43
%192 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%193 = call i32 (i32*, i8*, ...) @fscanf(i32* %191, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %192)
%194 = load i32*, i32** %43
%195 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%196 = call i32 (i32*, i8*, ...) @fscanf(i32* %194, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %195)
%197 = load i32*, i32** %43
%198 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%199 = call i32 (i32*, i8*, ...) @fscanf(i32* %197, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %198)
%200 = load i32*, i32** %43
%201 = call i32 (i32*, i8*, ...) @fscanf(i32* %200, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %37)
store i32 0, i32* %42
br label %202
202: ; preds = %209, %156
%203 = load i32, i32* %42
%204 = icmp slt i32 %203, 13
br i1 %204, label %205, label %212
205: ; preds = %202
%206 = load i32*, i32** %43
%207 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%208 = call i32 (i32*, i8*, ...) @fscanf(i32* %206, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %207)
br label %209
209: ; preds = %205
%210 = load i32, i32* %42
%211 = add nsw i32 %210, 1
store i32 %211, i32* %42
br label %202
212: ; preds = %202
%213 = load i32*, i32** %43
%214 = call i32 (i32*, i8*, ...) @fscanf(i32* %213, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %38)
br label %345
215: ; preds = %124
%216 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%217 = call i64 @strcmp(i8* %216, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0))
%218 = icmp eq i64 %217, 0
br i1 %218, label %219, label %227
219: ; preds = %215
%220 = load i32*, i32** %43
%221 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%222 = call i32 (i32*, i8*, ...) @fscanf(i32* %220, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %221)
%223 = load [126 x double]*, [126 x double]** %13
%224 = bitcast [126 x double]* %223 to double**
%225 = load i32*, i32** %43
%226 = call i32 @readMatrix(double** %224, i32* %225)
br label %344
227: ; preds = %215
%228 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%229 = call i64 @strcmp(i8* %228, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0))
%230 = icmp eq i64 %229, 0
br i1 %230, label %231, label %239
231: ; preds = %227
%232 = load i32*, i32** %43
%233 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%234 = call i32 (i32*, i8*, ...) @fscanf(i32* %232, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %233)
%235 = load [126 x double]*, [126 x double]** %14
%236 = bitcast [126 x double]* %235 to double**
%237 = load i32*, i32** %43
%238 = call i32 @readMatrix2(double** %236, i32* %237)
br label %343
239: ; preds = %227
%240 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%241 = call i64 @strcmp(i8* %240, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0))
%242 = icmp eq i64 %241, 0
br i1 %242, label %243, label %251
243: ; preds = %239
%244 = load i32*, i32** %43
%245 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%246 = call i32 (i32*, i8*, ...) @fscanf(i32* %244, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %245)
%247 = load [126 x double]*, [126 x double]** %15
%248 = bitcast [126 x double]* %247 to double**
%249 = load i32*, i32** %43
%250 = call i32 @readMatrix(double** %248, i32* %249)
br label %342
251: ; preds = %239
%252 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%253 = call i64 @strcmp(i8* %252, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0))
%254 = icmp eq i64 %253, 0
br i1 %254, label %255, label %263
255: ; preds = %251
%256 = load i32*, i32** %43
%257 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%258 = call i32 (i32*, i8*, ...) @fscanf(i32* %256, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %257)
%259 = load [126 x double]*, [126 x double]** %16
%260 = bitcast [126 x double]* %259 to double**
%261 = load i32*, i32** %43
%262 = call i32 @readMatrix2(double** %260, i32* %261)
br label %341
263: ; preds = %251
%264 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%265 = call i64 @strcmp(i8* %264, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.12, i64 0, i64 0))
%266 = icmp eq i64 %265, 0
br i1 %266, label %267, label %275
267: ; preds = %263
%268 = load i32*, i32** %43
%269 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%270 = call i32 (i32*, i8*, ...) @fscanf(i32* %268, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %269)
%271 = load [126 x double]*, [126 x double]** %17
%272 = bitcast [126 x double]* %271 to double**
%273 = load i32*, i32** %43
%274 = call i32 @readMatrix(double** %272, i32* %273)
br label %340
275: ; preds = %263
%276 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%277 = call i64 @strcmp(i8* %276, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.13, i64 0, i64 0))
%278 = icmp eq i64 %277, 0
br i1 %278, label %279, label %287
279: ; preds = %275
%280 = load i32*, i32** %43
%281 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%282 = call i32 (i32*, i8*, ...) @fscanf(i32* %280, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %281)
%283 = load [126 x double]*, [126 x double]** %18
%284 = bitcast [126 x double]* %283 to double**
%285 = load i32*, i32** %43
%286 = call i32 @readMatrix2(double** %284, i32* %285)
br label %339
287: ; preds = %275
%288 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%289 = call i64 @strcmp(i8* %288, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i64 0, i64 0))
%290 = icmp eq i64 %289, 0
br i1 %290, label %291, label %299
291: ; preds = %287
%292 = load i32*, i32** %43
%293 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%294 = call i32 (i32*, i8*, ...) @fscanf(i32* %292, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %293)
%295 = load [126 x double]*, [126 x double]** %19
%296 = bitcast [126 x double]* %295 to double**
%297 = load i32*, i32** %43
%298 = call i32 @readMatrix(double** %296, i32* %297)
br label %338
299: ; preds = %287
%300 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%301 = call i64 @strcmp(i8* %300, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.15, i64 0, i64 0))
%302 = icmp eq i64 %301, 0
br i1 %302, label %303, label %311
303: ; preds = %299
%304 = load i32*, i32** %43
%305 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%306 = call i32 (i32*, i8*, ...) @fscanf(i32* %304, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %305)
%307 = load [126 x double]*, [126 x double]** %20
%308 = bitcast [126 x double]* %307 to double**
%309 = load i32*, i32** %43
%310 = call i32 @readMatrix(double** %308, i32* %309)
br label %337
311: ; preds = %299
%312 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%313 = call i64 @strcmp(i8* %312, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.16, i64 0, i64 0))
%314 = icmp eq i64 %313, 0
br i1 %314, label %315, label %323
315: ; preds = %311
%316 = load i32*, i32** %43
%317 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%318 = call i32 (i32*, i8*, ...) @fscanf(i32* %316, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %317)
%319 = load [126 x double]*, [126 x double]** %21
%320 = bitcast [126 x double]* %319 to double**
%321 = load i32*, i32** %43
%322 = call i32 @readMatrix(double** %320, i32* %321)
br label %336
323: ; preds = %311
%324 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%325 = call i64 @strcmp(i8* %324, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.17, i64 0, i64 0))
%326 = icmp eq i64 %325, 0
br i1 %326, label %327, label %335
327: ; preds = %323
%328 = load i32*, i32** %43
%329 = getelementptr inbounds [300 x i8], [300 x i8]* %40, i64 0, i64 0
%330 = call i32 (i32*, i8*, ...) @fscanf(i32* %328, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %329)
%331 = load [126 x double]*, [126 x double]** %22
%332 = bitcast [126 x double]* %331 to double**
%333 = load i32*, i32** %43
%334 = call i32 @readMatrix(double** %332, i32* %333)
br label %335
335: ; preds = %327, %323
br label %336
336: ; preds = %335, %315
br label %337
337: ; preds = %336, %303
br label %338
338: ; preds = %337, %291
br label %339
339: ; preds = %338, %279
br label %340
340: ; preds = %339, %267
br label %341
341: ; preds = %340, %255
br label %342
342: ; preds = %341, %243
br label %343
343: ; preds = %342, %231
br label %344
344: ; preds = %343, %219
br label %345
345: ; preds = %344, %212
br label %346
346: ; preds = %345, %86
br label %347
347: ; preds = %346, %76
br label %348
348: ; preds = %347, %69
%349 = load i32*, i32** %43
%350 = call i32 (i32*, i8*, ...) @fscanf(i32* %349, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* %39)
br label %52
351: ; preds = %52
%352 = load i32*, i32** %43
%353 = call i32 @fclose(i32* %352)
%354 = load double, double* %23
%355 = load double*, double** %12
%356 = getelementptr inbounds double, double* %355, i64 0
store double %354, double* %356
%357 = load double, double* %24
%358 = load double*, double** %12
%359 = getelementptr inbounds double, double* %358, i64 1
store double %357, double* %359
%360 = load double, double* %25
%361 = load double*, double** %12
%362 = getelementptr inbounds double, double* %361, i64 2
store double %360, double* %362
%363 = load double, double* %26
%364 = load double*, double** %12
%365 = getelementptr inbounds double, double* %364, i64 3
store double %363, double* %365
%366 = load double, double* %27
%367 = load double*, double** %12
%368 = getelementptr inbounds double, double* %367, i64 4
store double %366, double* %368
%369 = load double, double* %28
%370 = load double*, double** %12
%371 = getelementptr inbounds double, double* %370, i64 5
store double %369, double* %371
%372 = load double, double* %29
%373 = load double*, double** %12
%374 = getelementptr inbounds double, double* %373, i64 6
store double %372, double* %374
%375 = load double, double* %30
%376 = load double*, double** %12
%377 = getelementptr inbounds double, double* %376, i64 7
store double %375, double* %377
%378 = load double, double* %31
%379 = load double*, double** %12
%380 = getelementptr inbounds double, double* %379, i64 8
store double %378, double* %380
%381 = load double, double* %32
%382 = load double*, double** %12
%383 = getelementptr inbounds double, double* %382, i64 9
store double %381, double* %383
%384 = load double, double* %33
%385 = load double*, double** %12
%386 = getelementptr inbounds double, double* %385, i64 10
store double %384, double* %386
%387 = load double, double* %34
%388 = load double*, double** %12
%389 = getelementptr inbounds double, double* %388, i64 11
store double %387, double* %389
%390 = load double, double* %35
%391 = load double*, double** %12
%392 = getelementptr inbounds double, double* %391, i64 12
store double %390, double* %392
%393 = load double, double* %36
%394 = load double*, double** %12
%395 = getelementptr inbounds double, double* %394, i64 13
store double %393, double* %395
%396 = load double, double* %37
%397 = load double*, double** %12
%398 = getelementptr inbounds double, double* %397, i64 14
store double %396, double* %398
%399 = load double, double* %38
%400 = load double*, double** %12
%401 = getelementptr inbounds double, double* %400, i64 15
store double %399, double* %401
br label %402
402: ; preds = %351, %47
ret void
}

LLVM IR (-O2):
@.str = [8 x i8] c"dba.txt\00"
@.str.1 = [2 x i8] c"r\00"
@.str.3 = [3 x i8] c"%c\00"
@.str.4 = [9 x i8] c"VELIVOLO\00"
@.str.5 = [3 x i8] c"%s\00"
@.str.6 = [4 x i8] c"%lg\00"
@.str.7 = [9 x i8] c"LOCATION\00"
@.str.8 = [3 x i8] c"Cm\00"
@.str.9 = [4 x i8] c"CXP\00"
@.str.10 = [4 x i8] c"CYA\00"
@.str.11 = [4 x i8] c"CZP\00"
@.str.12 = [4 x i8] c"ClA\00"
@.str.13 = [4 x i8] c"CmP\00"
@.str.14 = [4 x i8] c"CnA\00"
@.str.15 = [5 x i8] c"CYda\00"
@.str.16 = [5 x i8] c"Cnda\00"
@.str.17 = [5 x i8] c"Cmom\00"
@str = [25 x i8] c"File could not be opened\00"
define void @readDba(double* nocapture writeonly %0, [126 x double]* %1, [126 x double]* %2, [126 x double]* %3, [126 x double]* %4, [126 x double]* %5, [126 x double]* %6, [126 x double]* %7, [126 x double]* %8, [126 x double]* %9, [126 x double]* %10) {
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca i8
%29 = alloca [300 x i8]
%30 = bitcast double* %12 to i8*
%31 = bitcast double* %13 to i8*
%32 = bitcast double* %14 to i8*
%33 = bitcast double* %15 to i8*
%34 = bitcast double* %16 to i8*
%35 = bitcast double* %17 to i8*
%36 = bitcast double* %18 to i8*
%37 = bitcast double* %19 to i8*
%38 = bitcast double* %20 to i8*
%39 = bitcast double* %21 to i8*
%40 = bitcast double* %22 to i8*
%41 = bitcast double* %23 to i8*
%42 = bitcast double* %24 to i8*
%43 = bitcast double* %25 to i8*
%44 = bitcast double* %26 to i8*
%45 = bitcast double* %27 to i8*
%46 = getelementptr inbounds [300 x i8], [300 x i8]* %29, i64 0, i64 0
%47 = tail call i32* @fopen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%48 = icmp eq i32* %47, null
br i1 %48, label %49, label %51
49: ; preds = %11
%50 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @str, i64 0, i64 0))
br label %241
51: ; preds = %11
%52 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* %28)
%53 = call i32 @feof(i32* %47)
%54 = icmp eq i32 %53, 0
br i1 %54, label %55, label %208
55: ; preds = %51
%56 = bitcast [126 x double]* %10 to double**
%57 = bitcast [126 x double]* %9 to double**
%58 = bitcast [126 x double]* %8 to double**
%59 = bitcast [126 x double]* %7 to double**
%60 = bitcast [126 x double]* %6 to double**
%61 = bitcast [126 x double]* %5 to double**
%62 = bitcast [126 x double]* %4 to double**
%63 = bitcast [126 x double]* %3 to double**
%64 = bitcast [126 x double]* %2 to double**
%65 = bitcast [126 x double]* %1 to double**
br label %66
66: ; preds = %55, %203
%67 = phi i32 [ 0, %55 ], [ %204, %203 ]
%68 = load i8, i8* %28
switch i8 %68, label %69 [
i8 32, label %73
i8 10, label %73
i8 9, label %73
]
69: ; preds = %66
%70 = sext i32 %67 to i64
%71 = getelementptr inbounds [300 x i8], [300 x i8]* %29, i64 0, i64 %70
store i8 %68, i8* %71
%72 = add nsw i32 %67, 1
br label %203
73: ; preds = %66, %66, %66
%74 = icmp eq i32 %67, 0
br i1 %74, label %203, label %75
75: ; preds = %73
%76 = sext i32 %67 to i64
%77 = getelementptr inbounds [300 x i8], [300 x i8]* %29, i64 0, i64 %76
store i8 0, i8* %77
%78 = call i64 @strcmp(i8* %46, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.4, i64 0, i64 0))
%79 = icmp eq i64 %78, 0
br i1 %79, label %80, label %95
80: ; preds = %75
%81 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%82 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%83 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%84 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %12)
%85 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%86 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %13)
%87 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%88 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%89 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %14)
%90 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%91 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%92 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %15)
%93 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%94 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %16)
br label %203
95: ; preds = %75
%96 = call i64 @strcmp(i8* %46, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.7, i64 0, i64 0))
%97 = icmp eq i64 %96, 0
br i1 %97, label %98, label %143
98: ; preds = %95
%99 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %17)
%100 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%101 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %18)
%102 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%103 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %19)
%104 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%105 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %20)
br label %106
106: ; preds = %98, %106
%107 = phi i32 [ 0, %98 ], [ %109, %106 ]
%108 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%109 = add nuw nsw i32 %107, 1
%110 = icmp eq i32 %109, 39
br i1 %110, label %111, label %106
111: ; preds = %106
%112 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %22)
%113 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%114 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%115 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %21)
%116 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%117 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%118 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %23)
%119 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%120 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%121 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %24)
%122 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%123 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%124 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %25)
%125 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%126 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%127 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%128 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %26)
%129 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%130 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%131 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%132 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%133 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%134 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%135 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%136 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%137 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%138 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%139 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%140 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%141 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%142 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), double* %27)
br label %203
143: ; preds = %95
%144 = call i64 @strcmp(i8* %46, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0))
%145 = icmp eq i64 %144, 0
br i1 %145, label %146, label %149
146: ; preds = %143
%147 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%148 = call i32 @readMatrix(double** %65, i32* %47)
br label %203
149: ; preds = %143
%150 = call i64 @strcmp(i8* %46, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0))
%151 = icmp eq i64 %150, 0
br i1 %151, label %152, label %155
152: ; preds = %149
%153 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%154 = call i32 @readMatrix2(double** %64, i32* %47)
br label %203
155: ; preds = %149
%156 = call i64 @strcmp(i8* %46, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0))
%157 = icmp eq i64 %156, 0
br i1 %157, label %158, label %161
158: ; preds = %155
%159 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%160 = call i32 @readMatrix(double** %63, i32* %47)
br label %203
161: ; preds = %155
%162 = call i64 @strcmp(i8* %46, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0))
%163 = icmp eq i64 %162, 0
br i1 %163, label %164, label %167
164: ; preds = %161
%165 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%166 = call i32 @readMatrix2(double** %62, i32* %47)
br label %203
167: ; preds = %161
%168 = call i64 @strcmp(i8* %46, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.12, i64 0, i64 0))
%169 = icmp eq i64 %168, 0
br i1 %169, label %170, label %173
170: ; preds = %167
%171 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%172 = call i32 @readMatrix(double** %61, i32* %47)
br label %203
173: ; preds = %167
%174 = call i64 @strcmp(i8* %46, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.13, i64 0, i64 0))
%175 = icmp eq i64 %174, 0
br i1 %175, label %176, label %179
176: ; preds = %173
%177 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%178 = call i32 @readMatrix2(double** %60, i32* %47)
br label %203
179: ; preds = %173
%180 = call i64 @strcmp(i8* %46, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i64 0, i64 0))
%181 = icmp eq i64 %180, 0
br i1 %181, label %182, label %185
182: ; preds = %179
%183 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%184 = call i32 @readMatrix(double** %59, i32* %47)
br label %203
185: ; preds = %179
%186 = call i64 @strcmp(i8* %46, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.15, i64 0, i64 0))
%187 = icmp eq i64 %186, 0
br i1 %187, label %188, label %191
188: ; preds = %185
%189 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%190 = call i32 @readMatrix(double** %58, i32* %47)
br label %203
191: ; preds = %185
%192 = call i64 @strcmp(i8* %46, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.16, i64 0, i64 0))
%193 = icmp eq i64 %192, 0
br i1 %193, label %194, label %197
194: ; preds = %191
%195 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%196 = call i32 @readMatrix(double** %57, i32* %47)
br label %203
197: ; preds = %191
%198 = call i64 @strcmp(i8* %46, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.17, i64 0, i64 0))
%199 = icmp eq i64 %198, 0
br i1 %199, label %200, label %203
200: ; preds = %197
%201 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %46)
%202 = call i32 @readMatrix(double** %56, i32* %47)
br label %203
203: ; preds = %73, %111, %152, %164, %176, %188, %197, %200, %194, %182, %170, %158, %146, %80, %69
%204 = phi i32 [ %72, %69 ], [ 0, %80 ], [ 0, %111 ], [ 0, %146 ], [ 0, %152 ], [ 0, %158 ], [ 0, %164 ], [ 0, %170 ], [ 0, %176 ], [ 0, %182 ], [ 0, %188 ], [ 0, %194 ], [ 0, %200 ], [ 0, %197 ], [ 0, %73 ]
%205 = call i32 (i32*, i8*, ...) @fscanf(i32* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* %28)
%206 = call i32 @feof(i32* %47)
%207 = icmp eq i32 %206, 0
br i1 %207, label %66, label %208
208: ; preds = %203, %51
%209 = call i32 @fclose(i32* %47)
%210 = load double, double* %12
store double %210, double* %0
%211 = load double, double* %13
%212 = getelementptr inbounds double, double* %0, i64 1
store double %211, double* %212
%213 = load double, double* %14
%214 = getelementptr inbounds double, double* %0, i64 2
store double %213, double* %214
%215 = load double, double* %15
%216 = getelementptr inbounds double, double* %0, i64 3
store double %215, double* %216
%217 = load double, double* %16
%218 = getelementptr inbounds double, double* %0, i64 4
store double %217, double* %218
%219 = load double, double* %17
%220 = getelementptr inbounds double, double* %0, i64 5
store double %219, double* %220
%221 = load double, double* %18
%222 = getelementptr inbounds double, double* %0, i64 6
store double %221, double* %222
%223 = load double, double* %19
%224 = getelementptr inbounds double, double* %0, i64 7
store double %223, double* %224
%225 = load double, double* %20
%226 = getelementptr inbounds double, double* %0, i64 8
store double %225, double* %226
%227 = load double, double* %21
%228 = getelementptr inbounds double, double* %0, i64 9
store double %227, double* %228
%229 = load double, double* %22
%230 = getelementptr inbounds double, double* %0, i64 10
store double %229, double* %230
%231 = load double, double* %23
%232 = getelementptr inbounds double, double* %0, i64 11
store double %231, double* %232
%233 = load double, double* %24
%234 = getelementptr inbounds double, double* %0, i64 12
store double %233, double* %234
%235 = load double, double* %25
%236 = getelementptr inbounds double, double* %0, i64 13
store double %235, double* %236
%237 = load double, double* %26
%238 = getelementptr inbounds double, double* %0, i64 14
store double %237, double* %238
%239 = load double, double* %27
%240 = getelementptr inbounds double, double* %0, i64 15
store double %239, double* %240
br label %241
241: ; preds = %208, %49
ret void
}