#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*/ abs(int);
int pow(int, int);
int /*<<< orphan*/ printf(char *, ...);
int rand();
float sqrt(int /*<<< orphan*/);
int main() {
  int a[80], b[80], c[80], d[80 / 2], e[80];
  float f[80];
  int i = 0;
  for (i = 0; i < 80; i++) {
    a[i] = rand() % 1000;
    b[i] = rand() % 1000 + 200;
    c[i] = a[i] * b[i];
    if (i < 80 / 2) {
      d[i] = pow(rand() % 1000, 2);
    }
  }
  for (i = 0; i < 80 / 2; i++) {
    e[i] = a[i];
    e[i + 1] = b[rand() % 80];
    e[i + 2] = c[i + 80 / 2];
    e[i + 3] = d[i + 1];
  }
  printf("VECTORES CARGADOS: \n\nA\tB\tC\n\n");
  for (i = 0; i < 80; i++) {
    printf("%d\t%d\t%d\n", a[i], b[i], c[i]);
  }
  printf("\n\n\tD,\tE\n\n");
  for (i = 0; i < 80 / 2; i++)
    printf("\t%d\t%d\n", d[i], e[i]);
  printf("Llenando el vector F\n");
  printf("\n\nVector A\tVector B\tVector F\n\n");
  for (i = 0; i < 80; i++) {
    f[i] = sqrt(abs(a[i] - b[i]));
    printf("%d\t%d\t%.4f\n", a[i], b[i], f[i]);
  }
  int contador_paresA = 0, contador_imparesB = 0, suma_A = 0, suma_B = 0;
  float mediaA, mediaB;
  for (i = 0; i < 80; i++) {
    if (a[i] % 2 == 0)
      contador_paresA++;
    if (b[i] % 2 != 0)
      contador_imparesB++;
    suma_A = suma_A + a[i];
    suma_B += b[i];
  }
  mediaA = suma_A / 80;
  mediaB = suma_B / 80;
  printf("Media de A = %.3f y Media de B = %.3f.\n", mediaA, mediaB);
  printf("Cantidad de pares en A = %d, Cantidad de impares B = %d.\n\n",
         contador_paresA, contador_imparesB);
  printf("Ordenando A y B por burbuja.\n\n\n");
  int aux;
  int j;
  for (i = 1; i < 80; i++) {
    for (j = 0; j < 80 - 1; j++) {
      if (a[j] > a[j + 1]) {
        aux = a[j];
        a[j] = a[j + 1];
        a[j + 1] = aux;
      }
    }
  }
  for (i = 1; i < 80; i++) {
    for (j = 0; j < 80 - 1; j++) {
      if (b[j] < b[j + 1]) {
        aux = b[j];
        b[j] = b[j + 1];
        b[j + 1] = aux;
      }
    }
  }
  printf("ORDENADOS:\nVector A\tVectorB\n\n");
  for (i = 0; i < 80; i++)
    printf("%d\t%d\n", a[i], b[i]);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x720,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x6f4(%rbp)
movl   $0x0,-0x6f4(%rbp)
cmpl   $0x50,-0x6f4(%rbp)
jge    123f <main+0xef>
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x3e8,%ecx
cltd
idiv   %ecx
movslq -0x6f4(%rbp),%rax
mov    %edx,-0x150(%rbp,%rax,4)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x3e8,%ecx
cltd
idiv   %ecx
add    $0xc8,%edx
movslq -0x6f4(%rbp),%rax
mov    %edx,-0x290(%rbp,%rax,4)
movslq -0x6f4(%rbp),%rax
mov    -0x150(%rbp,%rax,4),%ecx
movslq -0x6f4(%rbp),%rax
imul   -0x290(%rbp,%rax,4),%ecx
ff
movslq -0x6f4(%rbp),%rax
mov    %ecx,-0x3d0(%rbp,%rax,4)
cmpl   $0x28,-0x6f4(%rbp)
jge    1226 <main+0xd6>
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x3e8,%ecx
cltd
idiv   %ecx
mov    %edx,%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    %eax,%ecx
movslq -0x6f4(%rbp),%rax
mov    %ecx,-0x470(%rbp,%rax,4)
jmp    122b <main+0xdb>
mov    -0x6f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6f4(%rbp)
jmp    1176 <main+0x26>
movl   $0x0,-0x6f4(%rbp)
cmpl   $0x28,-0x6f4(%rbp)
jge    12f9 <main+0x1a9>
movslq -0x6f4(%rbp),%rax
mov    -0x150(%rbp,%rax,4),%ecx
movslq -0x6f4(%rbp),%rax
mov    %ecx,-0x5b0(%rbp,%rax,4)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x50,%ecx
cltd
idiv   %ecx
movslq %edx,%rax
mov    -0x290(%rbp,%rax,4),%ecx
mov    -0x6f4(%rbp),%eax
add    $0x1,%eax
cltq
mov    %ecx,-0x5b0(%rbp,%rax,4)
mov    -0x6f4(%rbp),%eax
add    $0x28,%eax
cltq
mov    -0x3d0(%rbp,%rax,4),%ecx
mov    -0x6f4(%rbp),%eax
add    $0x2,%eax
cltq
mov    %ecx,-0x5b0(%rbp,%rax,4)
mov    -0x6f4(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x470(%rbp,%rax,4),%ecx
mov    -0x6f4(%rbp),%eax
add    $0x3,%eax
cltq
mov    %ecx,-0x5b0(%rbp,%rax,4)
mov    -0x6f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6f4(%rbp)
jmp    1249 <main+0xf9>
lea    0xd00(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x6f4(%rbp)
cmpl   $0x50,-0x6f4(%rbp)
jge    136a <main+0x21a>
movslq -0x6f4(%rbp),%rax
mov    -0x150(%rbp,%rax,4),%esi
movslq -0x6f4(%rbp),%rax
mov    -0x290(%rbp,%rax,4),%edx
movslq -0x6f4(%rbp),%rax
mov    -0x3d0(%rbp,%rax,4),%ecx
lea    0xcce(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x6f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6f4(%rbp)
jmp    1311 <main+0x1c1>
lea    0xcb6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x6f4(%rbp)
cmpl   $0x28,-0x6f4(%rbp)
jge    13cd <main+0x27d>
movslq -0x6f4(%rbp),%rax
mov    -0x470(%rbp,%rax,4),%esi
movslq -0x6f4(%rbp),%rax
mov    -0x5b0(%rbp,%rax,4),%edx
lea    0xc6d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x6f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6f4(%rbp)
jmp    1382 <main+0x232>
lea    0xc5d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xc65(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x6f4(%rbp)
cmpl   $0x50,-0x6f4(%rbp)
jge    148a <main+0x33a>
movslq -0x6f4(%rbp),%rax
mov    -0x150(%rbp,%rax,4),%edi
movslq -0x6f4(%rbp),%rax
sub    -0x290(%rbp,%rax,4),%edi
call   1030 <abs@plt>
mov    %eax,%edi
call   1060 <sqrt@plt>
movslq -0x6f4(%rbp),%rax
movss  %xmm0,-0x6f0(%rbp,%rax,4)
ff ff
movslq -0x6f4(%rbp),%rax
mov    -0x150(%rbp,%rax,4),%esi
movslq -0x6f4(%rbp),%rax
mov    -0x290(%rbp,%rax,4),%edx
movslq -0x6f4(%rbp),%rax
movss  -0x6f0(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
lea    0xbf7(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x6f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6f4(%rbp)
jmp    13f3 <main+0x2a3>
movl   $0x0,-0x6f8(%rbp)
movl   $0x0,-0x6fc(%rbp)
movl   $0x0,-0x700(%rbp)
movl   $0x0,-0x704(%rbp)
movl   $0x0,-0x6f4(%rbp)
cmpl   $0x50,-0x6f4(%rbp)
jge    156d <main+0x41d>
movslq -0x6f4(%rbp),%rax
mov    -0x150(%rbp,%rax,4),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    14f7 <main+0x3a7>
mov    -0x6f8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6f8(%rbp)
movslq -0x6f4(%rbp),%rax
mov    -0x290(%rbp,%rax,4),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     1525 <main+0x3d5>
mov    -0x6fc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6fc(%rbp)
mov    -0x700(%rbp),%eax
movslq -0x6f4(%rbp),%rcx
add    -0x150(%rbp,%rcx,4),%eax
mov    %eax,-0x700(%rbp)
movslq -0x6f4(%rbp),%rax
mov    -0x290(%rbp,%rax,4),%eax
add    -0x704(%rbp),%eax
mov    %eax,-0x704(%rbp)
mov    -0x6f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6f4(%rbp)
jmp    14bc <main+0x36c>
mov    -0x700(%rbp),%eax
mov    $0x50,%ecx
cltd
idiv   %ecx
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x708(%rbp)
ff
mov    -0x704(%rbp),%eax
mov    $0x50,%ecx
cltd
idiv   %ecx
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x70c(%rbp)
ff
movss  -0x708(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x70c(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
lea    0xab2(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
mov    -0x6f8(%rbp),%esi
mov    -0x6fc(%rbp),%edx
lea    0xac0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xaed(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x6f4(%rbp)
cmpl   $0x50,-0x6f4(%rbp)
jge    16c2 <main+0x572>
movl   $0x0,-0x714(%rbp)
cmpl   $0x4f,-0x714(%rbp)
jge    16a9 <main+0x559>
movslq -0x714(%rbp),%rax
mov    -0x150(%rbp,%rax,4),%eax
mov    -0x714(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmp    -0x150(%rbp,%rcx,4),%eax
jle    1690 <main+0x540>
movslq -0x714(%rbp),%rax
mov    -0x150(%rbp,%rax,4),%eax
mov    %eax,-0x710(%rbp)
mov    -0x714(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x150(%rbp,%rax,4),%ecx
movslq -0x714(%rbp),%rax
mov    %ecx,-0x150(%rbp,%rax,4)
mov    -0x710(%rbp),%ecx
mov    -0x714(%rbp),%eax
add    $0x1,%eax
cltq
mov    %ecx,-0x150(%rbp,%rax,4)
jmp    1695 <main+0x545>
mov    -0x714(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x714(%rbp)
jmp    1610 <main+0x4c0>
jmp    16ae <main+0x55e>
mov    -0x6f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6f4(%rbp)
jmp    15f9 <main+0x4a9>
movl   $0x1,-0x6f4(%rbp)
cmpl   $0x50,-0x6f4(%rbp)
jge    1795 <main+0x645>
movl   $0x0,-0x714(%rbp)
cmpl   $0x4f,-0x714(%rbp)
jge    177c <main+0x62c>
movslq -0x714(%rbp),%rax
mov    -0x290(%rbp,%rax,4),%eax
mov    -0x714(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmp    -0x290(%rbp,%rcx,4),%eax
jge    1763 <main+0x613>
movslq -0x714(%rbp),%rax
mov    -0x290(%rbp,%rax,4),%eax
mov    %eax,-0x710(%rbp)
mov    -0x714(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x290(%rbp,%rax,4),%ecx
movslq -0x714(%rbp),%rax
mov    %ecx,-0x290(%rbp,%rax,4)
mov    -0x710(%rbp),%ecx
mov    -0x714(%rbp),%eax
add    $0x1,%eax
cltq
mov    %ecx,-0x290(%rbp,%rax,4)
jmp    1768 <main+0x618>
mov    -0x714(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x714(%rbp)
jmp    16e3 <main+0x593>
jmp    1781 <main+0x631>
mov    -0x6f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6f4(%rbp)
jmp    16cc <main+0x57c>
lea    0x959(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x6f4(%rbp)
cmpl   $0x50,-0x6f4(%rbp)
jge    17f8 <main+0x6a8>
movslq -0x6f4(%rbp),%rax
mov    -0x150(%rbp,%rax,4),%esi
movslq -0x6f4(%rbp),%rax
mov    -0x290(%rbp,%rax,4),%edx
lea    0x843(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x6f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6f4(%rbp)
jmp    17ad <main+0x65d>
xor    %eax,%eax
add    $0x720,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x5a8,%rsp
xor    %ebx,%ebx
jmp    117e <main+0x2e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x50,%rbx
je     1226 <main+0xd6>
xor    %eax,%eax
call   1070 <rand@plt>
movslq %eax,%rbp
imul   $0x10624dd3,%rbp,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x26,%rax
add    %ecx,%eax
imul   $0x3e8,%eax,%eax
sub    %eax,%ebp
mov    %ebp,0x140(%rsp,%rbx,4)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x10624dd3,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x26,%rcx
add    %edx,%ecx
imul   $0x3e8,%ecx,%ecx
neg    %ecx
add    %ecx,%eax
add    $0xc8,%eax
mov    %eax,(%rsp,%rbx,4)
imul   %eax,%ebp
mov    %ebp,0x460(%rsp,%rbx,4)
cmp    $0x27,%rbx
ja     1170 <main+0x20>
xor    %eax,%eax
call   1070 <rand@plt>
movslq %eax,%rdi
imul   $0x10624dd3,%rdi,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x26,%rax
add    %ecx,%eax
imul   $0x3e8,%eax,%eax
sub    %eax,%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    %eax,0x280(%rsp,%rbx,4)
jmp    1170 <main+0x20>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    0x140(%rsp,%rbx,4),%eax
mov    %eax,0x320(%rsp,%rbx,4)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x25,%rcx
add    %edx,%ecx
shl    $0x4,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%eax
cltq
mov    (%rsp,%rax,4),%eax
mov    %eax,0x324(%rsp,%rbx,4)
mov    0x500(%rsp,%rbx,4),%eax
mov    %eax,0x328(%rsp,%rbx,4)
mov    0x284(%rsp,%rbx,4),%eax
mov    %eax,0x32c(%rsp,%rbx,4)
lea    0x1(%rbx),%rax
mov    %rax,%rbx
cmp    $0x28,%rax
jne    1230 <main+0xe0>
lea    0xdea(%rip),%rdi
call   1030 <puts@plt>
lea    0xd65(%rip),%rbx
xor    %ebp,%ebp
nopl   (%rax)
mov    0x140(%rsp,%rbp,4),%esi
mov    (%rsp,%rbp,4),%edx
mov    0x460(%rsp,%rbp,4),%ecx
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbp
cmp    $0x50,%rbp
jne    12b0 <main+0x160>
lea    0xdc9(%rip),%rdi
call   1030 <puts@plt>
lea    0xd2a(%rip),%rbx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    0x280(%rsp,%rbp,4),%esi
mov    0x320(%rsp,%rbp,4),%edx
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbp
cmp    $0x28,%rbp
jne    12f0 <main+0x1a0>
lea    0xd95(%rip),%rdi
call   1030 <puts@plt>
lea    0xd9e(%rip),%rdi
call   1030 <puts@plt>
xor    %ebx,%ebx
lea    0xce7(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x140(%rsp,%rbx,4),%ebp
mov    (%rsp,%rbx,4),%r15d
mov    %ebp,%eax
sub    %r15d,%eax
mov    %eax,%edi
neg    %edi
cmovs  %eax,%edi
call   1060 <sqrt@plt>
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    %ebp,%esi
mov    %r15d,%edx
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x1,%rbx
cmp    $0x50,%rbx
jne    1340 <main+0x1f0>
pxor   %xmm1,%xmm1
mov    $0x4,%eax
movdqa 0xc76(%rip),%xmm3
xorps  %xmm0,%xmm0
pxor   %xmm2,%xmm2
pxor   %xmm4,%xmm4
cs nopw 0x0(%rax,%rax,1)
nop
movdqa 0x130(%rsp,%rax,4),%xmm5
paddd  %xmm5,%xmm2
pandn  %xmm3,%xmm5
paddd  %xmm1,%xmm5
movdqa 0x140(%rsp,%rax,4),%xmm1
movdqa -0x10(%rsp,%rax,4),%xmm6
paddd  %xmm6,%xmm0
pand   %xmm3,%xmm6
paddd  %xmm4,%xmm6
movdqa (%rsp,%rax,4),%xmm4
paddd  %xmm1,%xmm2
pandn  %xmm3,%xmm1
paddd  %xmm5,%xmm1
paddd  %xmm4,%xmm0
pand   %xmm3,%xmm4
paddd  %xmm6,%xmm4
add    $0x8,%rax
cmp    $0x54,%rax
jne    13a0 <main+0x250>
pshufd $0xee,%xmm4,%xmm3
paddd  %xmm4,%xmm3
pshufd $0x55,%xmm3,%xmm4
paddd  %xmm3,%xmm4
movd   %xmm4,%ebx
pshufd $0xee,%xmm2,%xmm3
paddd  %xmm2,%xmm3
pshufd $0x55,%xmm3,%xmm2
paddd  %xmm3,%xmm2
movd   %xmm2,%eax
pshufd $0xee,%xmm0,%xmm2
paddd  %xmm0,%xmm2
pshufd $0x55,%xmm2,%xmm0
paddd  %xmm2,%xmm0
movd   %xmm0,%ecx
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
cltq
imul   $0x66666667,%rax,%rax
mov    %rax,%rdx
shr    $0x3f,%rdx
sar    $0x25,%rax
add    %edx,%eax
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
movslq %ecx,%rax
imul   $0x66666667,%rax,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x25,%rax
add    %ecx,%eax
xorps  %xmm3,%xmm3
cvtsi2ss %eax,%xmm3
paddd  %xmm0,%xmm1
movd   %xmm1,%ebp
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
lea    0xb87(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0xba1(%rip),%rdi
mov    %ebp,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xc22(%rip),%rdi
call   1030 <puts@plt>
mov    $0x1,%eax
jmp    14d8 <main+0x388>
nopl   0x0(%rax,%rax,1)
add    $0x1,%eax
cmp    $0x50,%eax
je     1547 <main+0x3f7>
mov    $0x2,%ecx
mov    0x140(%rsp),%edx
jmp    14f6 <main+0x3a6>
cs nopw 0x0(%rax,%rax,1)
mov    %esi,%edx
add    $0x2,%rcx
mov    0x13c(%rsp,%rcx,4),%esi
cmp    %esi,%edx
jle    1520 <main+0x3d0>
mov    %esi,0x138(%rsp,%rcx,4)
mov    %edx,0x13c(%rsp,%rcx,4)
cmp    $0x50,%rcx
jne    1528 <main+0x3d8>
jmp    14d0 <main+0x380>
nopw   0x0(%rax,%rax,1)
mov    %esi,%edx
cmp    $0x50,%rcx
je     14d0 <main+0x380>
mov    0x140(%rsp,%rcx,4),%esi
cmp    %esi,%edx
jle    14f0 <main+0x3a0>
mov    %esi,0x13c(%rsp,%rcx,4)
mov    %edx,0x140(%rsp,%rcx,4)
add    $0x2,%rcx
jmp    14f6 <main+0x3a6>
mov    $0x1,%eax
jmp    1558 <main+0x408>
xchg   %ax,%ax
add    $0x1,%eax
cmp    $0x50,%eax
je     15ac <main+0x45c>
mov    $0x2,%ecx
mov    (%rsp),%edx
jmp    1576 <main+0x426>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %esi,%edx
add    $0x2,%rcx
mov    -0x4(%rsp,%rcx,4),%esi
cmp    %esi,%edx
jge    1590 <main+0x440>
mov    %esi,-0x8(%rsp,%rcx,4)
mov    %edx,-0x4(%rsp,%rcx,4)
cmp    $0x50,%rcx
jne    1598 <main+0x448>
jmp    1550 <main+0x400>
xchg   %ax,%ax
mov    %esi,%edx
cmp    $0x50,%rcx
je     1550 <main+0x400>
mov    (%rsp,%rcx,4),%esi
cmp    %esi,%edx
jge    1570 <main+0x420>
mov    %esi,-0x4(%rsp,%rcx,4)
mov    %edx,(%rsp,%rcx,4)
add    $0x2,%rcx
jmp    1576 <main+0x426>
lea    0xb4d(%rip),%rdi
call   1030 <puts@plt>
lea    0xa54(%rip),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x140(%rsp,%rbp,4),%esi
mov    (%rsp,%rbp,4),%edx
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbp
cmp    $0x50,%rbp
jne    15d0 <main+0x480>
xor    %eax,%eax
add    $0x5a8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [29 x i8] c"VECTORES CARGADOS: \0A\0AA\09B\09C\0A\0A\00"
@.str.1 = [10 x i8] c"%d\09%d\09%d\0A\00"
@.str.2 = [10 x i8] c"\0A\0A\09D,\09E\0A\0A\00"
@.str.3 = [8 x i8] c"\09%d\09%d\0A\00"
@.str.4 = [22 x i8] c"Llenando el vector F\0A\00"
@.str.5 = [31 x i8] c"\0A\0AVector A\09Vector B\09Vector F\0A\0A\00"
@.str.6 = [12 x i8] c"%d\09%d\09%.4f\0A\00"
@.str.7 = [40 x i8] c"Media de A = %.3f y Media de B = %.3f.\0A\00"
@.str.8 = [59 x i8] c"Cantidad de pares en A = %d, Cantidad de impares B = %d.\0A\0A\00"
@.str.9 = [32 x i8] c"Ordenando A y B por burbuja.\0A\0A\0A\00"
@.str.10 = [30 x i8] c"ORDENADOS:\0AVector A\09VectorB\0A\0A\00"
@.str.11 = [7 x i8] c"%d\09%d\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [80 x i32]
%3 = alloca [80 x i32]
%4 = alloca [80 x i32]
%5 = alloca [40 x i32]
%6 = alloca [80 x i32]
%7 = alloca [80 x float]
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca float
%14 = alloca float
%15 = alloca i32
%16 = alloca i32
store i32 0, i32* %1
store i32 0, i32* %8
store i32 0, i32* %8
br label %17
17: ; preds = %54, %0
%18 = load i32, i32* %8
%19 = icmp slt i32 %18, 80
br i1 %19, label %20, label %57
20: ; preds = %17
%21 = call i32 (...) @rand()
%22 = srem i32 %21, 1000
%23 = load i32, i32* %8
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %24
store i32 %22, i32* %25
%26 = call i32 (...) @rand()
%27 = srem i32 %26, 1000
%28 = add nsw i32 %27, 200
%29 = load i32, i32* %8
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds [80 x i32], [80 x i32]* %3, i64 0, i64 %30
store i32 %28, i32* %31
%32 = load i32, i32* %8
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %33
%35 = load i32, i32* %34
%36 = load i32, i32* %8
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds [80 x i32], [80 x i32]* %3, i64 0, i64 %37
%39 = load i32, i32* %38
%40 = mul nsw i32 %35, %39
%41 = load i32, i32* %8
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [80 x i32], [80 x i32]* %4, i64 0, i64 %42
store i32 %40, i32* %43
%44 = load i32, i32* %8
%45 = icmp slt i32 %44, 40
br i1 %45, label %46, label %53
46: ; preds = %20
%47 = call i32 (...) @rand()
%48 = srem i32 %47, 1000
%49 = call i32 @pow(i32 %48, i32 2)
%50 = load i32, i32* %8
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds [40 x i32], [40 x i32]* %5, i64 0, i64 %51
store i32 %49, i32* %52
br label %53
53: ; preds = %46, %20
br label %54
54: ; preds = %53
%55 = load i32, i32* %8
%56 = add nsw i32 %55, 1
store i32 %56, i32* %8
br label %17
57: ; preds = %17
store i32 0, i32* %8
br label %58
58: ; preds = %96, %57
%59 = load i32, i32* %8
%60 = icmp slt i32 %59, 40
br i1 %60, label %61, label %99
61: ; preds = %58
%62 = load i32, i32* %8
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %63
%65 = load i32, i32* %64
%66 = load i32, i32* %8
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds [80 x i32], [80 x i32]* %6, i64 0, i64 %67
store i32 %65, i32* %68
%69 = call i32 (...) @rand()
%70 = srem i32 %69, 80
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [80 x i32], [80 x i32]* %3, i64 0, i64 %71
%73 = load i32, i32* %72
%74 = load i32, i32* %8
%75 = add nsw i32 %74, 1
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [80 x i32], [80 x i32]* %6, i64 0, i64 %76
store i32 %73, i32* %77
%78 = load i32, i32* %8
%79 = add nsw i32 %78, 40
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [80 x i32], [80 x i32]* %4, i64 0, i64 %80
%82 = load i32, i32* %81
%83 = load i32, i32* %8
%84 = add nsw i32 %83, 2
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [80 x i32], [80 x i32]* %6, i64 0, i64 %85
store i32 %82, i32* %86
%87 = load i32, i32* %8
%88 = add nsw i32 %87, 1
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [40 x i32], [40 x i32]* %5, i64 0, i64 %89
%91 = load i32, i32* %90
%92 = load i32, i32* %8
%93 = add nsw i32 %92, 3
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [80 x i32], [80 x i32]* %6, i64 0, i64 %94
store i32 %91, i32* %95
br label %96
96: ; preds = %61
%97 = load i32, i32* %8
%98 = add nsw i32 %97, 1
store i32 %98, i32* %8
br label %58
99: ; preds = %58
%100 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %8
br label %101
101: ; preds = %118, %99
%102 = load i32, i32* %8
%103 = icmp slt i32 %102, 80
br i1 %103, label %104, label %121
104: ; preds = %101
%105 = load i32, i32* %8
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %106
%108 = load i32, i32* %107
%109 = load i32, i32* %8
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds [80 x i32], [80 x i32]* %3, i64 0, i64 %110
%112 = load i32, i32* %111
%113 = load i32, i32* %8
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds [80 x i32], [80 x i32]* %4, i64 0, i64 %114
%116 = load i32, i32* %115
%117 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 %108, i32 %112, i32 %116)
br label %118
118: ; preds = %104
%119 = load i32, i32* %8
%120 = add nsw i32 %119, 1
store i32 %120, i32* %8
br label %101
121: ; preds = %101
%122 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0))
store i32 0, i32* %8
br label %123
123: ; preds = %136, %121
%124 = load i32, i32* %8
%125 = icmp slt i32 %124, 40
br i1 %125, label %126, label %139
126: ; preds = %123
%127 = load i32, i32* %8
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds [40 x i32], [40 x i32]* %5, i64 0, i64 %128
%130 = load i32, i32* %129
%131 = load i32, i32* %8
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds [80 x i32], [80 x i32]* %6, i64 0, i64 %132
%134 = load i32, i32* %133
%135 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0), i32 %130, i32 %134)
br label %136
136: ; preds = %126
%137 = load i32, i32* %8
%138 = add nsw i32 %137, 1
store i32 %138, i32* %8
br label %123
139: ; preds = %123
%140 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.4, i64 0, i64 0))
%141 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.5, i64 0, i64 0))
store i32 0, i32* %8
br label %142
142: ; preds = %174, %139
%143 = load i32, i32* %8
%144 = icmp slt i32 %143, 80
br i1 %144, label %145, label %177
145: ; preds = %142
%146 = load i32, i32* %8
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %147
%149 = load i32, i32* %148
%150 = load i32, i32* %8
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds [80 x i32], [80 x i32]* %3, i64 0, i64 %151
%153 = load i32, i32* %152
%154 = sub nsw i32 %149, %153
%155 = call i32 @abs(i32 %154)
%156 = call float @sqrt(i32 %155)
%157 = load i32, i32* %8
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds [80 x float], [80 x float]* %7, i64 0, i64 %158
store float %156, float* %159
%160 = load i32, i32* %8
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %161
%163 = load i32, i32* %162
%164 = load i32, i32* %8
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds [80 x i32], [80 x i32]* %3, i64 0, i64 %165
%167 = load i32, i32* %166
%168 = load i32, i32* %8
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds [80 x float], [80 x float]* %7, i64 0, i64 %169
%171 = load float, float* %170
%172 = fpext float %171 to double
%173 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.6, i64 0, i64 0), i32 %163, i32 %167, double %172)
br label %174
174: ; preds = %145
%175 = load i32, i32* %8
%176 = add nsw i32 %175, 1
store i32 %176, i32* %8
br label %142
177: ; preds = %142
store i32 0, i32* %9
store i32 0, i32* %10
store i32 0, i32* %11
store i32 0, i32* %12
store i32 0, i32* %8
br label %178
178: ; preds = %214, %177
%179 = load i32, i32* %8
%180 = icmp slt i32 %179, 80
br i1 %180, label %181, label %217
181: ; preds = %178
%182 = load i32, i32* %8
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %183
%185 = load i32, i32* %184
%186 = srem i32 %185, 2
%187 = icmp eq i32 %186, 0
br i1 %187, label %188, label %191
188: ; preds = %181
%189 = load i32, i32* %9
%190 = add nsw i32 %189, 1
store i32 %190, i32* %9
br label %191
191: ; preds = %188, %181
%192 = load i32, i32* %8
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds [80 x i32], [80 x i32]* %3, i64 0, i64 %193
%195 = load i32, i32* %194
%196 = srem i32 %195, 2
%197 = icmp ne i32 %196, 0
br i1 %197, label %198, label %201
198: ; preds = %191
%199 = load i32, i32* %10
%200 = add nsw i32 %199, 1
store i32 %200, i32* %10
br label %201
201: ; preds = %198, %191
%202 = load i32, i32* %11
%203 = load i32, i32* %8
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %204
%206 = load i32, i32* %205
%207 = add nsw i32 %202, %206
store i32 %207, i32* %11
%208 = load i32, i32* %8
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds [80 x i32], [80 x i32]* %3, i64 0, i64 %209
%211 = load i32, i32* %210
%212 = load i32, i32* %12
%213 = add nsw i32 %212, %211
store i32 %213, i32* %12
br label %214
214: ; preds = %201
%215 = load i32, i32* %8
%216 = add nsw i32 %215, 1
store i32 %216, i32* %8
br label %178
217: ; preds = %178
%218 = load i32, i32* %11
%219 = sdiv i32 %218, 80
%220 = sitofp i32 %219 to float
store float %220, float* %13
%221 = load i32, i32* %12
%222 = sdiv i32 %221, 80
%223 = sitofp i32 %222 to float
store float %223, float* %14
%224 = load float, float* %13
%225 = fpext float %224 to double
%226 = load float, float* %14
%227 = fpext float %226 to double
%228 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.7, i64 0, i64 0), double %225, double %227)
%229 = load i32, i32* %9
%230 = load i32, i32* %10
%231 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.8, i64 0, i64 0), i32 %229, i32 %230)
%232 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.9, i64 0, i64 0))
store i32 1, i32* %8
br label %233
233: ; preds = %274, %217
%234 = load i32, i32* %8
%235 = icmp slt i32 %234, 80
br i1 %235, label %236, label %277
236: ; preds = %233
store i32 0, i32* %16
br label %237
237: ; preds = %270, %236
%238 = load i32, i32* %16
%239 = icmp slt i32 %238, 79
br i1 %239, label %240, label %273
240: ; preds = %237
%241 = load i32, i32* %16
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %242
%244 = load i32, i32* %243
%245 = load i32, i32* %16
%246 = add nsw i32 %245, 1
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %247
%249 = load i32, i32* %248
%250 = icmp sgt i32 %244, %249
br i1 %250, label %251, label %269
251: ; preds = %240
%252 = load i32, i32* %16
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %253
%255 = load i32, i32* %254
store i32 %255, i32* %15
%256 = load i32, i32* %16
%257 = add nsw i32 %256, 1
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %258
%260 = load i32, i32* %259
%261 = load i32, i32* %16
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %262
store i32 %260, i32* %263
%264 = load i32, i32* %15
%265 = load i32, i32* %16
%266 = add nsw i32 %265, 1
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %267
store i32 %264, i32* %268
br label %269
269: ; preds = %251, %240
br label %270
270: ; preds = %269
%271 = load i32, i32* %16
%272 = add nsw i32 %271, 1
store i32 %272, i32* %16
br label %237
273: ; preds = %237
br label %274
274: ; preds = %273
%275 = load i32, i32* %8
%276 = add nsw i32 %275, 1
store i32 %276, i32* %8
br label %233
277: ; preds = %233
store i32 1, i32* %8
br label %278
278: ; preds = %319, %277
%279 = load i32, i32* %8
%280 = icmp slt i32 %279, 80
br i1 %280, label %281, label %322
281: ; preds = %278
store i32 0, i32* %16
br label %282
282: ; preds = %315, %281
%283 = load i32, i32* %16
%284 = icmp slt i32 %283, 79
br i1 %284, label %285, label %318
285: ; preds = %282
%286 = load i32, i32* %16
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds [80 x i32], [80 x i32]* %3, i64 0, i64 %287
%289 = load i32, i32* %288
%290 = load i32, i32* %16
%291 = add nsw i32 %290, 1
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds [80 x i32], [80 x i32]* %3, i64 0, i64 %292
%294 = load i32, i32* %293
%295 = icmp slt i32 %289, %294
br i1 %295, label %296, label %314
296: ; preds = %285
%297 = load i32, i32* %16
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds [80 x i32], [80 x i32]* %3, i64 0, i64 %298
%300 = load i32, i32* %299
store i32 %300, i32* %15
%301 = load i32, i32* %16
%302 = add nsw i32 %301, 1
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds [80 x i32], [80 x i32]* %3, i64 0, i64 %303
%305 = load i32, i32* %304
%306 = load i32, i32* %16
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds [80 x i32], [80 x i32]* %3, i64 0, i64 %307
store i32 %305, i32* %308
%309 = load i32, i32* %15
%310 = load i32, i32* %16
%311 = add nsw i32 %310, 1
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds [80 x i32], [80 x i32]* %3, i64 0, i64 %312
store i32 %309, i32* %313
br label %314
314: ; preds = %296, %285
br label %315
315: ; preds = %314
%316 = load i32, i32* %16
%317 = add nsw i32 %316, 1
store i32 %317, i32* %16
br label %282
318: ; preds = %282
br label %319
319: ; preds = %318
%320 = load i32, i32* %8
%321 = add nsw i32 %320, 1
store i32 %321, i32* %8
br label %278
322: ; preds = %278
%323 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.10, i64 0, i64 0))
store i32 0, i32* %8
br label %324
324: ; preds = %337, %322
%325 = load i32, i32* %8
%326 = icmp slt i32 %325, 80
br i1 %326, label %327, label %340
327: ; preds = %324
%328 = load i32, i32* %8
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %329
%331 = load i32, i32* %330
%332 = load i32, i32* %8
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds [80 x i32], [80 x i32]* %3, i64 0, i64 %333
%335 = load i32, i32* %334
%336 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.11, i64 0, i64 0), i32 %331, i32 %335)
br label %337
337: ; preds = %327
%338 = load i32, i32* %8
%339 = add nsw i32 %338, 1
store i32 %339, i32* %8
br label %324
340: ; preds = %324
ret i32 0
}

LLVM IR (-O2):
@.str.1 = [10 x i8] c"%d\09%d\09%d\0A\00"
@.str.3 = [8 x i8] c"\09%d\09%d\0A\00"
@.str.6 = [12 x i8] c"%d\09%d\09%.4f\0A\00"
@.str.7 = [40 x i8] c"Media de A = %.3f y Media de B = %.3f.\0A\00"
@.str.8 = [59 x i8] c"Cantidad de pares en A = %d, Cantidad de impares B = %d.\0A\0A\00"
@.str.11 = [7 x i8] c"%d\09%d\0A\00"
@str = [28 x i8] c"VECTORES CARGADOS: \0A\0AA\09B\09C\0A\00"
@str.12 = [9 x i8] c"\0A\0A\09D,\09E\0A\00"
@str.13 = [21 x i8] c"Llenando el vector F\00"
@str.14 = [30 x i8] c"\0A\0AVector A\09Vector B\09Vector F\0A\00"
@str.15 = [31 x i8] c"Ordenando A y B por burbuja.\0A\0A\00"
@str.16 = [29 x i8] c"ORDENADOS:\0AVector A\09VectorB\0A\00"
define i32 @main() {
%1 = alloca [80 x i32]
%2 = alloca [80 x i32]
%3 = alloca [80 x i32]
%4 = alloca [40 x i32]
%5 = alloca [80 x i32]
%6 = bitcast [80 x i32]* %1 to i8*
%7 = bitcast [80 x i32]* %2 to i8*
%8 = bitcast [80 x i32]* %3 to i8*
%9 = bitcast [40 x i32]* %4 to i8*
%10 = bitcast [80 x i32]* %5 to i8*
br label %11
11: ; preds = %0, %28
%12 = phi i64 [ 0, %0 ], [ %29, %28 ]
%13 = tail call i32 (...) @rand()
%14 = srem i32 %13, 1000
%15 = getelementptr inbounds [80 x i32], [80 x i32]* %1, i64 0, i64 %12
store i32 %14, i32* %15
%16 = tail call i32 (...) @rand()
%17 = srem i32 %16, 1000
%18 = add nsw i32 %17, 200
%19 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %12
store i32 %18, i32* %19
%20 = mul nsw i32 %18, %14
%21 = getelementptr inbounds [80 x i32], [80 x i32]* %3, i64 0, i64 %12
store i32 %20, i32* %21
%22 = icmp ult i64 %12, 40
br i1 %22, label %23, label %28
23: ; preds = %11
%24 = tail call i32 (...) @rand()
%25 = srem i32 %24, 1000
%26 = tail call i32 @pow(i32 %25, i32 2)
%27 = getelementptr inbounds [40 x i32], [40 x i32]* %4, i64 0, i64 %12
store i32 %26, i32* %27
br label %28
28: ; preds = %11, %23
%29 = add nuw nsw i64 %12, 1
%30 = icmp eq i64 %29, 80
br i1 %30, label %31, label %11
31: ; preds = %28, %31
%32 = phi i64 [ %41, %31 ], [ 0, %28 ]
%33 = getelementptr inbounds [80 x i32], [80 x i32]* %1, i64 0, i64 %32
%34 = load i32, i32* %33
%35 = getelementptr inbounds [80 x i32], [80 x i32]* %5, i64 0, i64 %32
store i32 %34, i32* %35
%36 = tail call i32 (...) @rand()
%37 = srem i32 %36, 80
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %38
%40 = load i32, i32* %39
%41 = add nuw nsw i64 %32, 1
%42 = getelementptr inbounds [80 x i32], [80 x i32]* %5, i64 0, i64 %41
store i32 %40, i32* %42
%43 = add nuw nsw i64 %32, 40
%44 = getelementptr inbounds [80 x i32], [80 x i32]* %3, i64 0, i64 %43
%45 = load i32, i32* %44
%46 = add nuw nsw i64 %32, 2
%47 = getelementptr inbounds [80 x i32], [80 x i32]* %5, i64 0, i64 %46
store i32 %45, i32* %47
%48 = getelementptr inbounds [40 x i32], [40 x i32]* %4, i64 0, i64 %41
%49 = load i32, i32* %48
%50 = add nuw nsw i64 %32, 3
%51 = getelementptr inbounds [80 x i32], [80 x i32]* %5, i64 0, i64 %50
store i32 %49, i32* %51
%52 = icmp eq i64 %41, 40
br i1 %52, label %53, label %31
53: ; preds = %31
%54 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str, i64 0, i64 0))
br label %55
55: ; preds = %53, %55
%56 = phi i64 [ 0, %53 ], [ %64, %55 ]
%57 = getelementptr inbounds [80 x i32], [80 x i32]* %1, i64 0, i64 %56
%58 = load i32, i32* %57
%59 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %56
%60 = load i32, i32* %59
%61 = getelementptr inbounds [80 x i32], [80 x i32]* %3, i64 0, i64 %56
%62 = load i32, i32* %61
%63 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 %58, i32 %60, i32 %62)
%64 = add nuw nsw i64 %56, 1
%65 = icmp eq i64 %64, 80
br i1 %65, label %66, label %55
66: ; preds = %55
%67 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @str.12, i64 0, i64 0))
br label %68
68: ; preds = %66, %68
%69 = phi i64 [ 0, %66 ], [ %75, %68 ]
%70 = getelementptr inbounds [40 x i32], [40 x i32]* %4, i64 0, i64 %69
%71 = load i32, i32* %70
%72 = getelementptr inbounds [80 x i32], [80 x i32]* %5, i64 0, i64 %69
%73 = load i32, i32* %72
%74 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0), i32 %71, i32 %73)
%75 = add nuw nsw i64 %69, 1
%76 = icmp eq i64 %75, 40
br i1 %76, label %77, label %68
77: ; preds = %68
%78 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.13, i64 0, i64 0))
%79 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @str.14, i64 0, i64 0))
br label %80
80: ; preds = %77, %80
%81 = phi i64 [ 0, %77 ], [ %91, %80 ]
%82 = getelementptr inbounds [80 x i32], [80 x i32]* %1, i64 0, i64 %81
%83 = load i32, i32* %82
%84 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %81
%85 = load i32, i32* %84
%86 = sub nsw i32 %83, %85
%87 = tail call i32 @llvm.abs.i32(i32 %86, i1 true)
%88 = tail call float @sqrt(i32 %87)
%89 = fpext float %88 to double
%90 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.6, i64 0, i64 0), i32 %83, i32 %85, double %89)
%91 = add nuw nsw i64 %81, 1
%92 = icmp eq i64 %91, 80
br i1 %92, label %93, label %80
93: ; preds = %80, %93
%94 = phi i64 [ %126, %93 ], [ 0, %80 ]
%95 = phi <4 x i32> [ %118, %93 ], [ zeroinitializer, %80 ]
%96 = phi <4 x i32> [ %125, %93 ], [ zeroinitializer, %80 ]
%97 = phi <4 x i32> [ %124, %93 ], [ zeroinitializer, %80 ]
%98 = phi <4 x i32> [ %123, %93 ], [ zeroinitializer, %80 ]
%99 = getelementptr inbounds [80 x i32], [80 x i32]* %1, i64 0, i64 %94
%100 = bitcast i32* %99 to <4 x i32>*
%101 = load <4 x i32>, <4 x i32>* %100
%102 = and <4 x i32> %101, <i32 1, i32 1, i32 1, i32 1>
%103 = xor <4 x i32> %102, <i32 1, i32 1, i32 1, i32 1>
%104 = add <4 x i32> %103, %95
%105 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %94
%106 = bitcast i32* %105 to <4 x i32>*
%107 = load <4 x i32>, <4 x i32>* %106
%108 = and <4 x i32> %107, <i32 1, i32 1, i32 1, i32 1>
%109 = add <4 x i32> %108, %98
%110 = add <4 x i32> %101, %97
%111 = add <4 x i32> %107, %96
%112 = or i64 %94, 4
%113 = getelementptr inbounds [80 x i32], [80 x i32]* %1, i64 0, i64 %112
%114 = bitcast i32* %113 to <4 x i32>*
%115 = load <4 x i32>, <4 x i32>* %114
%116 = and <4 x i32> %115, <i32 1, i32 1, i32 1, i32 1>
%117 = xor <4 x i32> %116, <i32 1, i32 1, i32 1, i32 1>
%118 = add <4 x i32> %117, %104
%119 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %112
%120 = bitcast i32* %119 to <4 x i32>*
%121 = load <4 x i32>, <4 x i32>* %120
%122 = and <4 x i32> %121, <i32 1, i32 1, i32 1, i32 1>
%123 = add <4 x i32> %122, %109
%124 = add <4 x i32> %115, %110
%125 = add <4 x i32> %121, %111
%126 = add nuw nsw i64 %94, 8
%127 = icmp eq i64 %126, 80
br i1 %127, label %128, label %93
128: ; preds = %93
%129 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %123)
%130 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %124)
%131 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %125)
%132 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %118)
%133 = sdiv i32 %130, 80
%134 = sitofp i32 %133 to float
%135 = sdiv i32 %131, 80
%136 = sitofp i32 %135 to float
%137 = fpext float %134 to double
%138 = fpext float %136 to double
%139 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.7, i64 0, i64 0), double %137, double %138)
%140 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @.str.8, i64 0, i64 0), i32 %132, i32 %129)
%141 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.15, i64 0, i64 0))
%142 = getelementptr inbounds [80 x i32], [80 x i32]* %1, i64 0, i64 0
br label %143
143: ; preds = %128, %167
%144 = phi i32 [ 1, %128 ], [ %168, %167 ]
%145 = load i32, i32* %142
br label %146
146: ; preds = %165, %143
%147 = phi i32 [ %145, %143 ], [ %166, %165 ]
%148 = phi i64 [ 0, %143 ], [ %159, %165 ]
%149 = or i64 %148, 1
%150 = getelementptr inbounds [80 x i32], [80 x i32]* %1, i64 0, i64 %149
%151 = load i32, i32* %150
%152 = icmp sgt i32 %147, %151
br i1 %152, label %153, label %155
153: ; preds = %146
%154 = getelementptr inbounds [80 x i32], [80 x i32]* %1, i64 0, i64 %148
store i32 %151, i32* %154
store i32 %147, i32* %150
br label %155
155: ; preds = %146, %153
%156 = phi i32 [ %151, %146 ], [ %147, %153 ]
%157 = icmp eq i64 %149, 79
br i1 %157, label %167, label %158
158: ; preds = %155
%159 = add nuw nsw i64 %148, 2
%160 = getelementptr inbounds [80 x i32], [80 x i32]* %1, i64 0, i64 %159
%161 = load i32, i32* %160
%162 = icmp sgt i32 %156, %161
br i1 %162, label %163, label %165
163: ; preds = %158
%164 = getelementptr inbounds [80 x i32], [80 x i32]* %1, i64 0, i64 %149
store i32 %161, i32* %164
store i32 %156, i32* %160
br label %165
165: ; preds = %163, %158
%166 = phi i32 [ %161, %158 ], [ %156, %163 ]
br label %146
167: ; preds = %155
%168 = add nuw nsw i32 %144, 1
%169 = icmp eq i32 %168, 80
br i1 %169, label %170, label %143
170: ; preds = %167
%171 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 0
br label %172
172: ; preds = %170, %196
%173 = phi i32 [ %197, %196 ], [ 1, %170 ]
%174 = load i32, i32* %171
br label %175
175: ; preds = %194, %172
%176 = phi i32 [ %174, %172 ], [ %195, %194 ]
%177 = phi i64 [ 0, %172 ], [ %188, %194 ]
%178 = or i64 %177, 1
%179 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %178
%180 = load i32, i32* %179
%181 = icmp slt i32 %176, %180
br i1 %181, label %182, label %184
182: ; preds = %175
%183 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %177
store i32 %180, i32* %183
store i32 %176, i32* %179
br label %184
184: ; preds = %175, %182
%185 = phi i32 [ %180, %175 ], [ %176, %182 ]
%186 = icmp eq i64 %178, 79
br i1 %186, label %196, label %187
187: ; preds = %184
%188 = add nuw nsw i64 %177, 2
%189 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %188
%190 = load i32, i32* %189
%191 = icmp slt i32 %185, %190
br i1 %191, label %192, label %194
192: ; preds = %187
%193 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %178
store i32 %190, i32* %193
store i32 %185, i32* %189
br label %194
194: ; preds = %192, %187
%195 = phi i32 [ %190, %187 ], [ %185, %192 ]
br label %175
196: ; preds = %184
%197 = add nuw nsw i32 %173, 1
%198 = icmp eq i32 %197, 80
br i1 %198, label %199, label %172
199: ; preds = %196
%200 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @str.16, i64 0, i64 0))
br label %201
201: ; preds = %199, %201
%202 = phi i64 [ 0, %199 ], [ %208, %201 ]
%203 = getelementptr inbounds [80 x i32], [80 x i32]* %1, i64 0, i64 %202
%204 = load i32, i32* %203
%205 = getelementptr inbounds [80 x i32], [80 x i32]* %2, i64 0, i64 %202
%206 = load i32, i32* %205
%207 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.11, i64 0, i64 0), i32 %204, i32 %206)
%208 = add nuw nsw i64 %202, 1
%209 = icmp eq i64 %208, 80
br i1 %209, label %210, label %201
210: ; preds = %201
ret i32 0
}