#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 */

/* Variables and functions */
int /*<<< orphan*/ MatriceMoltiplicazione(float **, float **, float **);
int /*<<< orphan*/ MatriceSomma(float **, float **, float **);
int /*<<< orphan*/ MatriceTrasposta(float **, float **);
int /*<<< orphan*/ ProdottoScalare(float **, float **);
int /*<<< orphan*/ StampaMatriceRisulta(float **);
int /*<<< orphan*/ getchar();
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ scanf(char *, int *);
int main() {
  float matrice[100][100] = {{0}};
  float matrice2[100][100] = {{0}};
  float matrice3[100][100] = {{0}};
  int Decisione = -1;
  while (Decisione < 0 || Decisione > 4) {
    printf("Selezionare il tipo di operazione da effettuare, digitando il "
           "numero corrispondente e premendo INVIO \n \n");
    printf("1. Matrice Scalare, moltiplica una Matrice per un valore dato. \n");
    printf("2. Matrice Trasposta, inverte la posizione delle righe con quelle "
           "delle colonne \n");
    printf("3. Somma di Matrici, somma due Matrici \n");
    printf(
        "4. Prodotto di Matrici, restituisce il prodotto tra due Matrici \n");
    printf("0. Esci \n \n");
    printf("Qualsiasi altro valore non verrà accettato\n");
    printf("Effettua la tua scelta: ");
    scanf("%d", &Decisione);
  }
  if (Decisione == 1) {
    printf("Hai scelto di calcolare una Matrice Scalare, premi INVIO per "
           "continuare \n");
    getchar();
    getchar();
    ProdottoScalare(matrice, matrice3);
    StampaMatriceRisulta(matrice3);
  } else if (Decisione == 2) {
    printf("Hai scelto di calcolare una Matrice Trasposta, premi INVIO per "
           "continuare \n");
    getchar();
    getchar();
    MatriceTrasposta(matrice, matrice3);
    StampaMatriceRisulta(matrice3);
  } else if (Decisione == 3) {
    printf("Hai scelto di calcolare una Somma tra due Matrici, premi INVIO per "
           "continuare \n");
    getchar();
    getchar();
    MatriceSomma(matrice, matrice2, matrice3);
    StampaMatriceRisulta(matrice3);
  } else if (Decisione == 4) {
    printf("Hai scelto di calcolare un Prodotto tra due Matrici, premi INVIO "
           "per continuare \n");
    getchar();
    getchar();
    MatriceMoltiplicazione(matrice, matrice2, matrice3);
    StampaMatriceRisulta(matrice3);
  }
  printf("\n\nGrazie per aver scelto il Nostro Programma, premi invio per "
         "uscire. \n\n\n Developed by Transistori");
  getchar();
  getchar();
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1d4e0,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x9c50(%rbp),%rdi
xor    %esi,%esi
mov    $0x9c40,%edx
call   1050 <memset@plt>
lea    -0x13890(%rbp),%rdi
xor    %esi,%esi
mov    $0x9c40,%edx
call   1050 <memset@plt>
lea    -0x1d4d0(%rbp),%rdi
xor    %esi,%esi
mov    $0x9c40,%edx
call   1050 <memset@plt>
movl   $0xffffffff,-0x1d4d4(%rbp)
ff ff ff
mov    $0x1,%al
cmpl   $0x0,-0x1d4d4(%rbp)
mov    %al,-0x1d4d5(%rbp)
jl     120a <main+0x7a>
cmpl   $0x4,-0x1d4d4(%rbp)
setg   %al
mov    %al,-0x1d4d5(%rbp)
mov    -0x1d4d5(%rbp),%al
test   $0x1,%al
jne    121d <main+0x8d>
jmp    1295 <main+0x105>
lea    0xddc(%rip),%rdi
call   1030 <printf@plt>
lea    0xe39(%rip),%rdi
call   1030 <printf@plt>
lea    0xe6e(%rip),%rdi
call   1030 <printf@plt>
lea    0xeb4(%rip),%rdi
call   1030 <printf@plt>
lea    0xed1(%rip),%rdi
call   1030 <printf@plt>
lea    0xf07(%rip),%rdi
call   1030 <printf@plt>
lea    0xf07(%rip),%rdi
call   1030 <printf@plt>
lea    0xf28(%rip),%rdi
call   1030 <printf@plt>
lea    0xf35(%rip),%rdi
lea    -0x1d4d4(%rbp),%rsi
call   10a0 <scanf@plt>
jmp    11e5 <main+0x55>
cmpl   $0x1,-0x1d4d4(%rbp)
jne    12e0 <main+0x150>
lea    0xf13(%rip),%rdi
call   1030 <printf@plt>
mov    $0x0,%al
call   1070 <getchar@plt>
mov    $0x0,%al
call   1070 <getchar@plt>
lea    -0x9c50(%rbp),%rdi
lea    -0x1d4d0(%rbp),%rsi
call   1060 <ProdottoScalare@plt>
lea    -0x1d4d0(%rbp),%rdi
call   1080 <StampaMatriceRisulta@plt>
jmp    13d9 <main+0x249>
cmpl   $0x2,-0x1d4d4(%rbp)
jne    132b <main+0x19b>
lea    0xf12(%rip),%rdi
call   1030 <printf@plt>
mov    $0x0,%al
call   1070 <getchar@plt>
mov    $0x0,%al
call   1070 <getchar@plt>
lea    -0x9c50(%rbp),%rdi
lea    -0x1d4d0(%rbp),%rsi
call   1040 <MatriceTrasposta@plt>
lea    -0x1d4d0(%rbp),%rdi
call   1080 <StampaMatriceRisulta@plt>
jmp    13d4 <main+0x244>
cmpl   $0x3,-0x1d4d4(%rbp)
jne    137d <main+0x1ed>
lea    0xf13(%rip),%rdi
call   1030 <printf@plt>
mov    $0x0,%al
call   1070 <getchar@plt>
mov    $0x0,%al
call   1070 <getchar@plt>
lea    -0x9c50(%rbp),%rdi
lea    -0x13890(%rbp),%rsi
lea    -0x1d4d0(%rbp),%rdx
call   10b0 <MatriceSomma@plt>
lea    -0x1d4d0(%rbp),%rdi
call   1080 <StampaMatriceRisulta@plt>
jmp    13cf <main+0x23f>
cmpl   $0x4,-0x1d4d4(%rbp)
jne    13ca <main+0x23a>
lea    0xf11(%rip),%rdi
call   1030 <printf@plt>
mov    $0x0,%al
call   1070 <getchar@plt>
mov    $0x0,%al
call   1070 <getchar@plt>
lea    -0x9c50(%rbp),%rdi
lea    -0x13890(%rbp),%rsi
lea    -0x1d4d0(%rbp),%rdx
call   1090 <MatriceMoltiplicazione@plt>
lea    -0x1d4d0(%rbp),%rdi
call   1080 <StampaMatriceRisulta@plt>
jmp    13cf <main+0x23f>
jmp    13d4 <main+0x244>
jmp    13d9 <main+0x249>
lea    0xf14(%rip),%rdi
call   1030 <printf@plt>
mov    $0x0,%al
call   1070 <getchar@plt>
mov    $0x0,%al
call   1070 <getchar@plt>
xor    %eax,%eax
add    $0x1d4e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1d4d8,%rsp
lea    0x9c50(%rsp),%rdi
mov    $0x9c40,%edx
xor    %esi,%esi
call   1060 <memset@plt>
lea    0x13890(%rsp),%rdi
mov    $0x9c40,%edx
xor    %esi,%esi
call   1060 <memset@plt>
lea    0x10(%rsp),%rdi
mov    $0x9c40,%edx
xor    %esi,%esi
call   1060 <memset@plt>
movl   $0xffffffff,0xc(%rsp)
ff
lea    0x10eb(%rip),%rbx
lea    0x1125(%rip),%rbp
lea    0x1129(%rip),%r14
lea    0xe02(%rip),%r15
lea    0xe14(%rip),%r12
lea    0xc(%rsp),%r13
nopw   0x0(%rax,%rax,1)
lea    0xf9c(%rip),%rdi
call   1030 <puts@plt>
lea    0xff8(%rip),%rdi
call   1030 <puts@plt>
lea    0x102c(%rip),%rdi
call   1030 <puts@plt>
lea    0x1071(%rip),%rdi
call   1030 <puts@plt>
mov    %rbx,%rdi
call   1030 <puts@plt>
mov    %rbp,%rdi
call   1030 <puts@plt>
mov    %r14,%rdi
call   1030 <puts@plt>
mov    %r15,%rdi
call   1040 <printf@plt>
mov    %r12,%rdi
mov    %r13,%rsi
call   10b0 <scanf@plt>
mov    0xc(%rsp),%eax
cmp    $0x4,%eax
ja     1220 <main+0x80>
add    $0xffffffff,%eax
cmp    $0x3,%eax
ja     1373 <main+0x1d3>
lea    0xd69(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0xed3(%rip),%rdi
call   1030 <puts@plt>
xor    %eax,%eax
call   1080 <getchar@plt>
xor    %eax,%eax
call   1080 <getchar@plt>
lea    0x9c50(%rsp),%rdi
lea    0x10(%rsp),%rsi
call   1070 <ProdottoScalare@plt>
jmp    1369 <main+0x1c9>
lea    0xe57(%rip),%rdi
call   1030 <puts@plt>
xor    %eax,%eax
call   1080 <getchar@plt>
xor    %eax,%eax
call   1080 <getchar@plt>
lea    0x9c50(%rsp),%rdi
lea    0x10(%rsp),%rsi
call   1050 <MatriceTrasposta@plt>
jmp    1369 <main+0x1c9>
lea    0xdda(%rip),%rdi
call   1030 <puts@plt>
xor    %eax,%eax
call   1080 <getchar@plt>
xor    %eax,%eax
call   1080 <getchar@plt>
lea    0x9c50(%rsp),%rdi
lea    0x13890(%rsp),%rsi
lea    0x10(%rsp),%rdx
call   10c0 <MatriceSomma@plt>
jmp    1369 <main+0x1c9>
lea    0xd53(%rip),%rdi
call   1030 <puts@plt>
xor    %eax,%eax
call   1080 <getchar@plt>
xor    %eax,%eax
call   1080 <getchar@plt>
lea    0x9c50(%rsp),%rdi
lea    0x13890(%rsp),%rsi
lea    0x10(%rsp),%rdx
call   10a0 <MatriceMoltiplicazione@plt>
lea    0x10(%rsp),%rdi
call   1090 <StampaMatriceRisulta@plt>
lea    0xcb2(%rip),%rdi
call   1040 <printf@plt>
xor    %eax,%eax
call   1080 <getchar@plt>
xor    %eax,%eax
call   1080 <getchar@plt>
xor    %eax,%eax
add    $0x1d4d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [105 x i8] c"Selezionare il tipo di operazione da effettuare, digitando il numero corrispondente e premendo INVIO \0A \0A\00"
@.str.1 = [65 x i8] c"1. Matrice Scalare, moltiplica una Matrice per un valore dato. \0A\00"
@.str.2 = [82 x i8] c"2. Matrice Trasposta, inverte la posizione delle righe con quelle delle colonne \0A\00"
@.str.3 = [41 x i8] c"3. Somma di Matrici, somma due Matrici \0A\00"
@.str.4 = [66 x i8] c"4. Prodotto di Matrici, restituisce il prodotto tra due Matrici \0A\00"
@.str.5 = [12 x i8] c"0. Esci \0A \0A\00"
@.str.6 = [45 x i8] c"Qualsiasi altro valore non verr\C3\A0 accettato\0A\00"
@.str.7 = [25 x i8] c"Effettua la tua scelta: \00"
@.str.8 = [3 x i8] c"%d\00"
@.str.9 = [74 x i8] c"Hai scelto di calcolare una Matrice Scalare, premi INVIO per continuare \0A\00"
@.str.10 = [76 x i8] c"Hai scelto di calcolare una Matrice Trasposta, premi INVIO per continuare \0A\00"
@.str.11 = [80 x i8] c"Hai scelto di calcolare una Somma tra due Matrici, premi INVIO per continuare \0A\00"
@.str.12 = [82 x i8] c"Hai scelto di calcolare un Prodotto tra due Matrici, premi INVIO per continuare \0A\00"
@.str.13 = [99 x i8] c"\0A\0AGrazie per aver scelto il Nostro Programma, premi invio per uscire. \0A\0A\0A Developed by Transistori\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [100 x [100 x float]]
%3 = alloca [100 x [100 x float]]
%4 = alloca [100 x [100 x float]]
%5 = alloca i32
store i32 0, i32* %1
%6 = bitcast [100 x [100 x float]]* %2 to i8*
%7 = bitcast [100 x [100 x float]]* %3 to i8*
%8 = bitcast [100 x [100 x float]]* %4 to i8*
store i32 -1, i32* %5
br label %9
9: ; preds = %17, %0
%10 = load i32, i32* %5
%11 = icmp slt i32 %10, 0
br i1 %11, label %15, label %12
12: ; preds = %9
%13 = load i32, i32* %5
%14 = icmp sgt i32 %13, 4
br label %15
15: ; preds = %12, %9
%16 = phi i1 [ true, %9 ], [ %14, %12 ]
br i1 %16, label %17, label %27
17: ; preds = %15
%18 = call i32 @printf(i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str, i64 0, i64 0))
%19 = call i32 @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.1, i64 0, i64 0))
%20 = call i32 @printf(i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.2, i64 0, i64 0))
%21 = call i32 @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.3, i64 0, i64 0))
%22 = call i32 @printf(i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.4, i64 0, i64 0))
%23 = call i32 @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.5, i64 0, i64 0))
%24 = call i32 @printf(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.6, i64 0, i64 0))
%25 = call i32 @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.7, i64 0, i64 0))
%26 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), i32* %5)
br label %9
27: ; preds = %15
%28 = load i32, i32* %5
%29 = icmp eq i32 %28, 1
br i1 %29, label %30, label %42
30: ; preds = %27
%31 = call i32 @printf(i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.9, i64 0, i64 0))
%32 = call i32 (...) @getchar()
%33 = call i32 (...) @getchar()
%34 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 0
%35 = bitcast [100 x float]* %34 to float**
%36 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %4, i64 0, i64 0
%37 = bitcast [100 x float]* %36 to float**
%38 = call i32 @ProdottoScalare(float** %35, float** %37)
%39 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %4, i64 0, i64 0
%40 = bitcast [100 x float]* %39 to float**
%41 = call i32 @StampaMatriceRisulta(float** %40)
br label %94
42: ; preds = %27
%43 = load i32, i32* %5
%44 = icmp eq i32 %43, 2
br i1 %44, label %45, label %57
45: ; preds = %42
%46 = call i32 @printf(i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.10, i64 0, i64 0))
%47 = call i32 (...) @getchar()
%48 = call i32 (...) @getchar()
%49 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 0
%50 = bitcast [100 x float]* %49 to float**
%51 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %4, i64 0, i64 0
%52 = bitcast [100 x float]* %51 to float**
%53 = call i32 @MatriceTrasposta(float** %50, float** %52)
%54 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %4, i64 0, i64 0
%55 = bitcast [100 x float]* %54 to float**
%56 = call i32 @StampaMatriceRisulta(float** %55)
br label %93
57: ; preds = %42
%58 = load i32, i32* %5
%59 = icmp eq i32 %58, 3
br i1 %59, label %60, label %74
60: ; preds = %57
%61 = call i32 @printf(i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.11, i64 0, i64 0))
%62 = call i32 (...) @getchar()
%63 = call i32 (...) @getchar()
%64 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 0
%65 = bitcast [100 x float]* %64 to float**
%66 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 0
%67 = bitcast [100 x float]* %66 to float**
%68 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %4, i64 0, i64 0
%69 = bitcast [100 x float]* %68 to float**
%70 = call i32 @MatriceSomma(float** %65, float** %67, float** %69)
%71 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %4, i64 0, i64 0
%72 = bitcast [100 x float]* %71 to float**
%73 = call i32 @StampaMatriceRisulta(float** %72)
br label %92
74: ; preds = %57
%75 = load i32, i32* %5
%76 = icmp eq i32 %75, 4
br i1 %76, label %77, label %91
77: ; preds = %74
%78 = call i32 @printf(i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.12, i64 0, i64 0))
%79 = call i32 (...) @getchar()
%80 = call i32 (...) @getchar()
%81 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %2, i64 0, i64 0
%82 = bitcast [100 x float]* %81 to float**
%83 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %3, i64 0, i64 0
%84 = bitcast [100 x float]* %83 to float**
%85 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %4, i64 0, i64 0
%86 = bitcast [100 x float]* %85 to float**
%87 = call i32 @MatriceMoltiplicazione(float** %82, float** %84, float** %86)
%88 = getelementptr inbounds [100 x [100 x float]], [100 x [100 x float]]* %4, i64 0, i64 0
%89 = bitcast [100 x float]* %88 to float**
%90 = call i32 @StampaMatriceRisulta(float** %89)
br label %91
91: ; preds = %77, %74
br label %92
92: ; preds = %91, %60
br label %93
93: ; preds = %92, %45
br label %94
94: ; preds = %93, %30
%95 = call i32 @printf(i8* getelementptr inbounds ([99 x i8], [99 x i8]* @.str.13, i64 0, i64 0))
%96 = call i32 (...) @getchar()
%97 = call i32 (...) @getchar()
ret i32 0
}

LLVM IR (-O2):
@.str.7 = [25 x i8] c"Effettua la tua scelta: \00"
@.str.8 = [3 x i8] c"%d\00"
@.str.13 = [99 x i8] c"\0A\0AGrazie per aver scelto il Nostro Programma, premi invio per uscire. \0A\0A\0A Developed by Transistori\00"
@str = [81 x i8] c"Hai scelto di calcolare un Prodotto tra due Matrici, premi INVIO per continuare \00"
@str.14 = [79 x i8] c"Hai scelto di calcolare una Somma tra due Matrici, premi INVIO per continuare \00"
@str.15 = [75 x i8] c"Hai scelto di calcolare una Matrice Trasposta, premi INVIO per continuare \00"
@str.16 = [73 x i8] c"Hai scelto di calcolare una Matrice Scalare, premi INVIO per continuare \00"
@str.17 = [104 x i8] c"Selezionare il tipo di operazione da effettuare, digitando il numero corrispondente e premendo INVIO \0A \00"
@str.18 = [64 x i8] c"1. Matrice Scalare, moltiplica una Matrice per un valore dato. \00"
@str.19 = [81 x i8] c"2. Matrice Trasposta, inverte la posizione delle righe con quelle delle colonne \00"
@str.20 = [40 x i8] c"3. Somma di Matrici, somma due Matrici \00"
@str.21 = [65 x i8] c"4. Prodotto di Matrici, restituisce il prodotto tra due Matrici \00"
@str.22 = [11 x i8] c"0. Esci \0A \00"
@str.23 = [44 x i8] c"Qualsiasi altro valore non verr\C3\A0 accettato\00"
define i32 @main() {
%1 = alloca [100 x [100 x float]]
%2 = alloca [100 x [100 x float]]
%3 = alloca [100 x [100 x float]]
%4 = alloca i32
%5 = bitcast [100 x [100 x float]]* %1 to i8*
%6 = bitcast [100 x [100 x float]]* %2 to i8*
%7 = bitcast [100 x [100 x float]]* %3 to i8*
%8 = bitcast i32* %4 to i8*
store i32 -1, i32* %4
br label %9
9: ; preds = %0, %9
%10 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([104 x i8], [104 x i8]* @str.17, i64 0, i64 0))
%11 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([64 x i8], [64 x i8]* @str.18, i64 0, i64 0))
%12 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([81 x i8], [81 x i8]* @str.19, i64 0, i64 0))
%13 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @str.20, i64 0, i64 0))
%14 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([65 x i8], [65 x i8]* @str.21, i64 0, i64 0))
%15 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.22, i64 0, i64 0))
%16 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @str.23, i64 0, i64 0))
%17 = call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.7, i64 0, i64 0))
%18 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), i32* %4)
%19 = load i32, i32* %4
%20 = icmp ugt i32 %19, 4
br i1 %20, label %9, label %21
21: ; preds = %9
switch i32 %19, label %55 [
i32 1, label %22
i32 2, label %29
i32 3, label %36
i32 4, label %44
]
22: ; preds = %21
%23 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([73 x i8], [73 x i8]* @str.16, i64 0, i64 0))
%24 = call i32 (...) @getchar()
%25 = call i32 (...) @getchar()
%26 = bitcast [100 x [100 x float]]* %1 to float**
%27 = bitcast [100 x [100 x float]]* %3 to float**
%28 = call i32 @ProdottoScalare(float** %26, float** %27)
br label %52
29: ; preds = %21
%30 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([75 x i8], [75 x i8]* @str.15, i64 0, i64 0))
%31 = call i32 (...) @getchar()
%32 = call i32 (...) @getchar()
%33 = bitcast [100 x [100 x float]]* %1 to float**
%34 = bitcast [100 x [100 x float]]* %3 to float**
%35 = call i32 @MatriceTrasposta(float** %33, float** %34)
br label %52
36: ; preds = %21
%37 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([79 x i8], [79 x i8]* @str.14, i64 0, i64 0))
%38 = call i32 (...) @getchar()
%39 = call i32 (...) @getchar()
%40 = bitcast [100 x [100 x float]]* %1 to float**
%41 = bitcast [100 x [100 x float]]* %2 to float**
%42 = bitcast [100 x [100 x float]]* %3 to float**
%43 = call i32 @MatriceSomma(float** %40, float** %41, float** %42)
br label %52
44: ; preds = %21
%45 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([81 x i8], [81 x i8]* @str, i64 0, i64 0))
%46 = call i32 (...) @getchar()
%47 = call i32 (...) @getchar()
%48 = bitcast [100 x [100 x float]]* %1 to float**
%49 = bitcast [100 x [100 x float]]* %2 to float**
%50 = bitcast [100 x [100 x float]]* %3 to float**
%51 = call i32 @MatriceMoltiplicazione(float** %48, float** %49, float** %50)
br label %52
52: ; preds = %22, %36, %44, %29
%53 = bitcast [100 x [100 x float]]* %3 to float**
%54 = call i32 @StampaMatriceRisulta(float** %53)
br label %55
55: ; preds = %52, %21
%56 = call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([99 x i8], [99 x i8]* @.str.13, i64 0, i64 0))
%57 = call i32 (...) @getchar()
%58 = call i32 (...) @getchar()
ret i32 0
}