#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*/ printf(char *, ...);
int main(void) {
  int matrix[7][7], f, c, A = 0, s;
  for (f = 0; f <= 7; f++) {
    for (c = 0; c <= 7; c++) {
      matrix[f][c] = A;
      A = A + 6;
    }
  }
  printf("\nEsta es la matriz original:\n\n");
  for (f = 0; f <= 6; f++) {
    for (c = 0; c <= 6; c++) {
      printf("%d\t", matrix[f][c]);
    }
    printf("\n");
  }
  printf("\nEsta es la matriz transpuesta:\n\n");
  for (f = 0; f <= 6; f++) {
    for (c = 0; c <= 6; c++) {
      printf("%d\t", matrix[c][f]);
    }
    printf("\n");
  }
  s = 0;
  for (f = 2; f <= 4; f++) {
    for (c = 2; c <= 4; c++) {
      if (f == 2 || f == 4)
        s = s + matrix[f][c];
    }
  }
  for (f = 1; f <= 5; f++) {
    for (c = 2; c <= 4; c++) {
      if (f == 2 || f == 4)
        s = s + matrix[f][c];
    }
  }
  for (f = 2; f <= 4; f++) {
    for (c = 1; c <= 5; c++) {
      if (c == 2 || c == 4)
        s = s + matrix[f][c];
    }
  }
  s = s + matrix[1][1] + matrix[1][5] + matrix[5][1] + matrix[5][5];
  printf("\nLa suma de los bordes es igual a: %d", s);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0xdc(%rbp)
movl   $0x0,-0xd4(%rbp)
cmpl   $0x7,-0xd4(%rbp)
jg     11bb <main+0xab>
movl   $0x0,-0xd8(%rbp)
cmpl   $0x7,-0xd8(%rbp)
jg     11a2 <main+0x92>
mov    -0xdc(%rbp),%edx
movslq -0xd4(%rbp),%rcx
lea    -0xd0(%rbp),%rax
imul   $0x1c,%rcx,%rcx
add    %rcx,%rax
movslq -0xd8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xdc(%rbp),%eax
add    $0x6,%eax
mov    %eax,-0xdc(%rbp)
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    114d <main+0x3d>
jmp    11a7 <main+0x97>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    1136 <main+0x26>
lea    0xe3e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xd4(%rbp)
cmpl   $0x6,-0xd4(%rbp)
jg     125a <main+0x14a>
movl   $0x0,-0xd8(%rbp)
cmpl   $0x6,-0xd8(%rbp)
jg     1238 <main+0x128>
movslq -0xd4(%rbp),%rcx
lea    -0xd0(%rbp),%rax
imul   $0x1c,%rcx,%rcx
add    %rcx,%rax
movslq -0xd8(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xe02(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    11ea <main+0xda>
lea    0xe04(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    11d3 <main+0xc3>
lea    0xdc2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xd4(%rbp)
cmpl   $0x6,-0xd4(%rbp)
jg     12f9 <main+0x1e9>
movl   $0x0,-0xd8(%rbp)
cmpl   $0x6,-0xd8(%rbp)
jg     12d7 <main+0x1c7>
movslq -0xd8(%rbp),%rcx
lea    -0xd0(%rbp),%rax
imul   $0x1c,%rcx,%rcx
add    %rcx,%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xd63(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    1289 <main+0x179>
lea    0xd65(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    1272 <main+0x162>
movl   $0x0,-0xe0(%rbp)
movl   $0x2,-0xd4(%rbp)
cmpl   $0x4,-0xd4(%rbp)
jg     13a8 <main+0x298>
movl   $0x2,-0xd8(%rbp)
cmpl   $0x4,-0xd8(%rbp)
jg     138f <main+0x27f>
cmpl   $0x2,-0xd4(%rbp)
je     134b <main+0x23b>
cmpl   $0x4,-0xd4(%rbp)
jne    1376 <main+0x266>
mov    -0xe0(%rbp),%eax
movslq -0xd4(%rbp),%rdx
lea    -0xd0(%rbp),%rcx
imul   $0x1c,%rdx,%rdx
add    %rdx,%rcx
movslq -0xd8(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0xe0(%rbp)
jmp    137b <main+0x26b>
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    1324 <main+0x214>
jmp    1394 <main+0x284>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    130d <main+0x1fd>
movl   $0x1,-0xd4(%rbp)
cmpl   $0x5,-0xd4(%rbp)
jg     144d <main+0x33d>
movl   $0x2,-0xd8(%rbp)
cmpl   $0x4,-0xd8(%rbp)
jg     1434 <main+0x324>
cmpl   $0x2,-0xd4(%rbp)
je     13f0 <main+0x2e0>
cmpl   $0x4,-0xd4(%rbp)
jne    141b <main+0x30b>
mov    -0xe0(%rbp),%eax
movslq -0xd4(%rbp),%rdx
lea    -0xd0(%rbp),%rcx
imul   $0x1c,%rdx,%rdx
add    %rdx,%rcx
movslq -0xd8(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0xe0(%rbp)
jmp    1420 <main+0x310>
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    13c9 <main+0x2b9>
jmp    1439 <main+0x329>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    13b2 <main+0x2a2>
movl   $0x2,-0xd4(%rbp)
cmpl   $0x4,-0xd4(%rbp)
jg     14f2 <main+0x3e2>
movl   $0x1,-0xd8(%rbp)
cmpl   $0x5,-0xd8(%rbp)
jg     14d9 <main+0x3c9>
cmpl   $0x2,-0xd8(%rbp)
je     1495 <main+0x385>
cmpl   $0x4,-0xd8(%rbp)
jne    14c0 <main+0x3b0>
mov    -0xe0(%rbp),%eax
movslq -0xd4(%rbp),%rdx
lea    -0xd0(%rbp),%rcx
imul   $0x1c,%rdx,%rdx
add    %rdx,%rcx
movslq -0xd8(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0xe0(%rbp)
jmp    14c5 <main+0x3b5>
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    146e <main+0x35e>
jmp    14de <main+0x3ce>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    1457 <main+0x347>
mov    -0xe0(%rbp),%eax
add    -0xb0(%rbp),%eax
add    -0xa0(%rbp),%eax
add    -0x40(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0xe0(%rbp)
mov    -0xe0(%rbp),%esi
lea    0xb28(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r14
push   %rbx
sub    $0xc8,%rsp
movaps 0xebf(%rip),%xmm0
movaps %xmm0,(%rsp)
movaps 0xec4(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xec8(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0xecc(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
movaps 0xed0(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
movaps 0xed4(%rip),%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0xed8(%rip),%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0xedc(%rip),%xmm0
movaps %xmm0,0x70(%rsp)
movaps 0xee0(%rip),%xmm0
movaps %xmm0,0x80(%rsp)
movaps 0xee1(%rip),%xmm0
movaps %xmm0,0x90(%rsp)
movaps 0xee2(%rip),%xmm0
movaps %xmm0,0xa0(%rsp)
movaps 0xee3(%rip),%xmm0
movaps %xmm0,0xb0(%rsp)
movaps 0xee4(%rip),%xmm0
movaps %xmm0,0xc0(%rsp)
movaps 0xee5(%rip),%xmm0
movaps %xmm0,0xd0(%rsp)
movl   $0x17a,0xe0(%rsp)
lea    0xf05(%rip),%rdi
call   1040 <puts@plt>
mov    $0x18,%ebx
lea    0xeca(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
mov    -0x18(%rsp,%rbx,1),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    -0x14(%rsp,%rbx,1),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    -0x10(%rsp,%rbx,1),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    -0xc(%rsp,%rbx,1),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    -0x8(%rsp,%rbx,1),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    -0x4(%rsp,%rbx,1),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    (%rsp,%rbx,1),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1c,%rbx
cmp    $0xdc,%rbx
jne    1220 <main+0xf0>
lea    0xe89(%rip),%rdi
call   1040 <puts@plt>
mov    $0xfffffffffffffff9,%rbx
lea    0xe2e(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x1c(%rsp,%rbx,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x38(%rsp,%rbx,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x54(%rsp,%rbx,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x70(%rsp,%rbx,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x8c(%rsp,%rbx,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xa8(%rsp,%rbx,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xc4(%rsp,%rbx,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
inc    %rbx
jne    12c0 <main+0x190>
mov    0x20(%rsp),%eax
mov    0x30(%rsp),%ecx
lea    (%rax,%rcx,1),%esi
add    $0xd68,%esi
lea    0xd92(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
xor    %eax,%eax
add    $0xc8,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
@.str = [31 x i8] c"\0AEsta es la matriz original:\0A\0A\00"
@.str.1 = [4 x i8] c"%d\09\00"
@.str.2 = [2 x i8] c"\0A\00"
@.str.3 = [34 x i8] c"\0AEsta es la matriz transpuesta:\0A\0A\00"
@.str.4 = [38 x i8] c"\0ALa suma de los bordes es igual a: %d\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [7 x [7 x i32]]
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
store i32 0, i32* %1
store i32 0, i32* %5
store i32 0, i32* %3
br label %7
7: ; preds = %28, %0
%8 = load i32, i32* %3
%9 = icmp sle i32 %8, 7
br i1 %9, label %10, label %31
10: ; preds = %7
store i32 0, i32* %4
br label %11
11: ; preds = %24, %10
%12 = load i32, i32* %4
%13 = icmp sle i32 %12, 7
br i1 %13, label %14, label %27
14: ; preds = %11
%15 = load i32, i32* %5
%16 = load i32, i32* %3
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %2, i64 0, i64 %17
%19 = load i32, i32* %4
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds [7 x i32], [7 x i32]* %18, i64 0, i64 %20
store i32 %15, i32* %21
%22 = load i32, i32* %5
%23 = add nsw i32 %22, 6
store i32 %23, i32* %5
br label %24
24: ; preds = %14
%25 = load i32, i32* %4
%26 = add nsw i32 %25, 1
store i32 %26, i32* %4
br label %11
27: ; preds = %11
br label %28
28: ; preds = %27
%29 = load i32, i32* %3
%30 = add nsw i32 %29, 1
store i32 %30, i32* %3
br label %7
31: ; preds = %7
%32 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %3
br label %33
33: ; preds = %54, %31
%34 = load i32, i32* %3
%35 = icmp sle i32 %34, 6
br i1 %35, label %36, label %57
36: ; preds = %33
store i32 0, i32* %4
br label %37
37: ; preds = %49, %36
%38 = load i32, i32* %4
%39 = icmp sle i32 %38, 6
br i1 %39, label %40, label %52
40: ; preds = %37
%41 = load i32, i32* %3
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %2, i64 0, i64 %42
%44 = load i32, i32* %4
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [7 x i32], [7 x i32]* %43, i64 0, i64 %45
%47 = load i32, i32* %46
%48 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %47)
br label %49
49: ; preds = %40
%50 = load i32, i32* %4
%51 = add nsw i32 %50, 1
store i32 %51, i32* %4
br label %37
52: ; preds = %37
%53 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
br label %54
54: ; preds = %52
%55 = load i32, i32* %3
%56 = add nsw i32 %55, 1
store i32 %56, i32* %3
br label %33
57: ; preds = %33
%58 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.3, i64 0, i64 0))
store i32 0, i32* %3
br label %59
59: ; preds = %80, %57
%60 = load i32, i32* %3
%61 = icmp sle i32 %60, 6
br i1 %61, label %62, label %83
62: ; preds = %59
store i32 0, i32* %4
br label %63
63: ; preds = %75, %62
%64 = load i32, i32* %4
%65 = icmp sle i32 %64, 6
br i1 %65, label %66, label %78
66: ; preds = %63
%67 = load i32, i32* %4
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %2, i64 0, i64 %68
%70 = load i32, i32* %3
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [7 x i32], [7 x i32]* %69, i64 0, i64 %71
%73 = load i32, i32* %72
%74 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %73)
br label %75
75: ; preds = %66
%76 = load i32, i32* %4
%77 = add nsw i32 %76, 1
store i32 %77, i32* %4
br label %63
78: ; preds = %63
%79 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
br label %80
80: ; preds = %78
%81 = load i32, i32* %3
%82 = add nsw i32 %81, 1
store i32 %82, i32* %3
br label %59
83: ; preds = %59
store i32 0, i32* %6
store i32 2, i32* %3
br label %84
84: ; preds = %112, %83
%85 = load i32, i32* %3
%86 = icmp sle i32 %85, 4
br i1 %86, label %87, label %115
87: ; preds = %84
store i32 2, i32* %4
br label %88
88: ; preds = %108, %87
%89 = load i32, i32* %4
%90 = icmp sle i32 %89, 4
br i1 %90, label %91, label %111
91: ; preds = %88
%92 = load i32, i32* %3
%93 = icmp eq i32 %92, 2
br i1 %93, label %97, label %94
94: ; preds = %91
%95 = load i32, i32* %3
%96 = icmp eq i32 %95, 4
br i1 %96, label %97, label %107
97: ; preds = %94, %91
%98 = load i32, i32* %6
%99 = load i32, i32* %3
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %2, i64 0, i64 %100
%102 = load i32, i32* %4
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds [7 x i32], [7 x i32]* %101, i64 0, i64 %103
%105 = load i32, i32* %104
%106 = add nsw i32 %98, %105
store i32 %106, i32* %6
br label %107
107: ; preds = %97, %94
br label %108
108: ; preds = %107
%109 = load i32, i32* %4
%110 = add nsw i32 %109, 1
store i32 %110, i32* %4
br label %88
111: ; preds = %88
br label %112
112: ; preds = %111
%113 = load i32, i32* %3
%114 = add nsw i32 %113, 1
store i32 %114, i32* %3
br label %84
115: ; preds = %84
store i32 1, i32* %3
br label %116
116: ; preds = %144, %115
%117 = load i32, i32* %3
%118 = icmp sle i32 %117, 5
br i1 %118, label %119, label %147
119: ; preds = %116
store i32 2, i32* %4
br label %120
120: ; preds = %140, %119
%121 = load i32, i32* %4
%122 = icmp sle i32 %121, 4
br i1 %122, label %123, label %143
123: ; preds = %120
%124 = load i32, i32* %3
%125 = icmp eq i32 %124, 2
br i1 %125, label %129, label %126
126: ; preds = %123
%127 = load i32, i32* %3
%128 = icmp eq i32 %127, 4
br i1 %128, label %129, label %139
129: ; preds = %126, %123
%130 = load i32, i32* %6
%131 = load i32, i32* %3
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %2, i64 0, i64 %132
%134 = load i32, i32* %4
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds [7 x i32], [7 x i32]* %133, i64 0, i64 %135
%137 = load i32, i32* %136
%138 = add nsw i32 %130, %137
store i32 %138, i32* %6
br label %139
139: ; preds = %129, %126
br label %140
140: ; preds = %139
%141 = load i32, i32* %4
%142 = add nsw i32 %141, 1
store i32 %142, i32* %4
br label %120
143: ; preds = %120
br label %144
144: ; preds = %143
%145 = load i32, i32* %3
%146 = add nsw i32 %145, 1
store i32 %146, i32* %3
br label %116
147: ; preds = %116
store i32 2, i32* %3
br label %148
148: ; preds = %176, %147
%149 = load i32, i32* %3
%150 = icmp sle i32 %149, 4
br i1 %150, label %151, label %179
151: ; preds = %148
store i32 1, i32* %4
br label %152
152: ; preds = %172, %151
%153 = load i32, i32* %4
%154 = icmp sle i32 %153, 5
br i1 %154, label %155, label %175
155: ; preds = %152
%156 = load i32, i32* %4
%157 = icmp eq i32 %156, 2
br i1 %157, label %161, label %158
158: ; preds = %155
%159 = load i32, i32* %4
%160 = icmp eq i32 %159, 4
br i1 %160, label %161, label %171
161: ; preds = %158, %155
%162 = load i32, i32* %6
%163 = load i32, i32* %3
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %2, i64 0, i64 %164
%166 = load i32, i32* %4
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds [7 x i32], [7 x i32]* %165, i64 0, i64 %167
%169 = load i32, i32* %168
%170 = add nsw i32 %162, %169
store i32 %170, i32* %6
br label %171
171: ; preds = %161, %158
br label %172
172: ; preds = %171
%173 = load i32, i32* %4
%174 = add nsw i32 %173, 1
store i32 %174, i32* %4
br label %152
175: ; preds = %152
br label %176
176: ; preds = %175
%177 = load i32, i32* %3
%178 = add nsw i32 %177, 1
store i32 %178, i32* %3
br label %148
179: ; preds = %148
%180 = load i32, i32* %6
%181 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %2, i64 0, i64 1
%182 = getelementptr inbounds [7 x i32], [7 x i32]* %181, i64 0, i64 1
%183 = load i32, i32* %182
%184 = add nsw i32 %180, %183
%185 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %2, i64 0, i64 1
%186 = getelementptr inbounds [7 x i32], [7 x i32]* %185, i64 0, i64 5
%187 = load i32, i32* %186
%188 = add nsw i32 %184, %187
%189 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %2, i64 0, i64 5
%190 = getelementptr inbounds [7 x i32], [7 x i32]* %189, i64 0, i64 1
%191 = load i32, i32* %190
%192 = add nsw i32 %188, %191
%193 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %2, i64 0, i64 5
%194 = getelementptr inbounds [7 x i32], [7 x i32]* %193, i64 0, i64 5
%195 = load i32, i32* %194
%196 = add nsw i32 %192, %195
store i32 %196, i32* %6
%197 = load i32, i32* %6
%198 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.4, i64 0, i64 0), i32 %197)
ret i32 0
}

LLVM IR (-O2):
@.str.1 = [4 x i8] c"%d\09\00"
@.str.4 = [38 x i8] c"\0ALa suma de los bordes es igual a: %d\00"
@str = [30 x i8] c"\0AEsta es la matriz original:\0A\00"
@str.5 = [33 x i8] c"\0AEsta es la matriz transpuesta:\0A\00"
define i32 @main() {
%1 = alloca [7 x [7 x i32]]
%2 = bitcast [7 x [7 x i32]]* %1 to i8*
%3 = bitcast [7 x [7 x i32]]* %1 to <4 x i32>*
store <4 x i32> <i32 0, i32 6, i32 12, i32 18>, <4 x i32>* %3
%4 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 0, i64 4
%5 = bitcast i32* %4 to <4 x i32>*
store <4 x i32> <i32 24, i32 30, i32 36, i32 48>, <4 x i32>* %5
%6 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 1, i64 1
%7 = bitcast i32* %6 to <4 x i32>*
store <4 x i32> <i32 54, i32 60, i32 66, i32 72>, <4 x i32>* %7
%8 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 1, i64 5
%9 = bitcast i32* %8 to <4 x i32>*
store <4 x i32> <i32 78, i32 84, i32 96, i32 102>, <4 x i32>* %9
%10 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 2, i64 2
%11 = bitcast i32* %10 to <4 x i32>*
store <4 x i32> <i32 108, i32 114, i32 120, i32 126>, <4 x i32>* %11
%12 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 2, i64 6
%13 = bitcast i32* %12 to <4 x i32>*
store <4 x i32> <i32 132, i32 144, i32 150, i32 156>, <4 x i32>* %13
%14 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 3, i64 3
%15 = bitcast i32* %14 to <4 x i32>*
store <4 x i32> <i32 162, i32 168, i32 174, i32 180>, <4 x i32>* %15
%16 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 4, i64 0
%17 = bitcast i32* %16 to <4 x i32>*
store <4 x i32> <i32 192, i32 198, i32 204, i32 210>, <4 x i32>* %17
%18 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 4, i64 4
%19 = bitcast i32* %18 to <4 x i32>*
store <4 x i32> <i32 216, i32 222, i32 228, i32 240>, <4 x i32>* %19
%20 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 5, i64 1
%21 = bitcast i32* %20 to <4 x i32>*
store <4 x i32> <i32 246, i32 252, i32 258, i32 264>, <4 x i32>* %21
%22 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 5, i64 5
%23 = bitcast i32* %22 to <4 x i32>*
store <4 x i32> <i32 270, i32 276, i32 288, i32 294>, <4 x i32>* %23
%24 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 6, i64 2
%25 = bitcast i32* %24 to <4 x i32>*
store <4 x i32> <i32 300, i32 306, i32 312, i32 318>, <4 x i32>* %25
%26 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 6, i64 6
%27 = bitcast i32* %26 to <4 x i32>*
store <4 x i32> <i32 324, i32 336, i32 342, i32 348>, <4 x i32>* %27
%28 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 7, i64 3
%29 = bitcast i32* %28 to <4 x i32>*
store <4 x i32> <i32 354, i32 360, i32 366, i32 372>, <4 x i32>* %29
%30 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 7, i64 7
store i32 378, i32* %30
%31 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @str, i64 0, i64 0))
br label %32
32: ; preds = %0, %32
%33 = phi i64 [ 0, %0 ], [ %56, %32 ]
%34 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 %33, i64 0
%35 = load i32, i32* %34
%36 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %35)
%37 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 %33, i64 1
%38 = load i32, i32* %37
%39 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %38)
%40 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 %33, i64 2
%41 = load i32, i32* %40
%42 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %41)
%43 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 %33, i64 3
%44 = load i32, i32* %43
%45 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %44)
%46 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 %33, i64 4
%47 = load i32, i32* %46
%48 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %47)
%49 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 %33, i64 5
%50 = load i32, i32* %49
%51 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %50)
%52 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 %33, i64 6
%53 = load i32, i32* %52
%54 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %53)
%55 = tail call i32 @putchar(i32 10)
%56 = add nuw nsw i64 %33, 1
%57 = icmp eq i64 %56, 7
br i1 %57, label %58, label %32
58: ; preds = %32
%59 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @str.5, i64 0, i64 0))
br label %60
60: ; preds = %58, %60
%61 = phi i64 [ 0, %58 ], [ %84, %60 ]
%62 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 0, i64 %61
%63 = load i32, i32* %62
%64 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %63)
%65 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 1, i64 %61
%66 = load i32, i32* %65
%67 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %66)
%68 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 2, i64 %61
%69 = load i32, i32* %68
%70 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %69)
%71 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 3, i64 %61
%72 = load i32, i32* %71
%73 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %72)
%74 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 4, i64 %61
%75 = load i32, i32* %74
%76 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %75)
%77 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 5, i64 %61
%78 = load i32, i32* %77
%79 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %78)
%80 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %1, i64 0, i64 6, i64 %61
%81 = load i32, i32* %80
%82 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %81)
%83 = tail call i32 @putchar(i32 10)
%84 = add nuw nsw i64 %61, 1
%85 = icmp eq i64 %84, 7
br i1 %85, label %86, label %60
86: ; preds = %60
%87 = load i32, i32* %6
%88 = add nsw i32 %87, 2916
%89 = load i32, i32* %8
%90 = add nsw i32 %88, %89
%91 = add nsw i32 %90, 516
%92 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str.4, i64 0, i64 0), i32 %91)
ret i32 0
}