#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 */
float fabs(float);
float cota_vector(float *vector1, float *vector2, int tamanio) {
  float cotas[tamanio];
  float cota = 0;
  int i;
  for (i = 0; i < tamanio; i++) {
    cotas[i] = fabs(vector1[i] - vector2[i]);
  }
  for (i = 0; i < tamanio; i++) {
    if (cotas[i] > cota) {
      cota = cotas[i];
    }
  }
  return cota;
}


x86 assembly (clang, -O0):
<cota_vector>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x20(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x38(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    119f <cota_vector+0x8f>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
mov    -0x38(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1159 <cota_vector+0x49>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11ee <cota_vector+0xde>
mov    -0x38(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x2c(%rbp),%xmm0
jbe    11db <cota_vector+0xcb>
mov    -0x38(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
jmp    11e0 <cota_vector+0xd0>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11a6 <cota_vector+0x96>
movss  -0x2c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cota_vector>:
push   %rbp
mov    %rsp,%rbp
mov    %edx,%r8d
mov    %rsp,%r9
lea    0xf(,%r8,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r9
mov    %r9,%rsp
xorps  %xmm0,%xmm0
test   %edx,%edx
jle    12d5 <cota_vector+0x1d5>
cmp    $0x8,%edx
jae    1133 <cota_vector+0x33>
xor    %ecx,%ecx
jmp    120a <cota_vector+0x10a>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rax,%rax
je     12da <cota_vector+0x1da>
mov    %r10,%r11
and    $0xfffffffffffffffe,%r11
xor    %eax,%eax
movaps 0xe9f(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rdi,%rax,4),%xmm2
movups 0x10(%rdi,%rax,4),%xmm3
movups (%rsi,%rax,4),%xmm4
subps  %xmm4,%xmm2
movups 0x10(%rsi,%rax,4),%xmm4
subps  %xmm4,%xmm3
andps  %xmm1,%xmm2
andps  %xmm1,%xmm3
movaps %xmm2,(%r9,%rax,4)
movaps %xmm3,0x10(%r9,%rax,4)
movups 0x20(%rdi,%rax,4),%xmm2
movups 0x30(%rdi,%rax,4),%xmm3
movups 0x20(%rsi,%rax,4),%xmm4
subps  %xmm4,%xmm2
movups 0x30(%rsi,%rax,4),%xmm4
subps  %xmm4,%xmm3
andps  %xmm1,%xmm2
andps  %xmm1,%xmm3
movaps %xmm2,0x20(%r9,%rax,4)
movaps %xmm3,0x30(%r9,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%r11
jne    1170 <cota_vector+0x70>
test   $0x1,%r10b
je     1205 <cota_vector+0x105>
movups (%rdi,%rax,4),%xmm1
movups 0x10(%rdi,%rax,4),%xmm2
movups (%rsi,%rax,4),%xmm3
subps  %xmm3,%xmm1
movups 0x10(%rsi,%rax,4),%xmm3
subps  %xmm3,%xmm2
movaps 0xe0c(%rip),%xmm3
andps  %xmm3,%xmm1
andps  %xmm3,%xmm2
movaps %xmm1,(%r9,%rax,4)
movaps %xmm2,0x10(%r9,%rax,4)
cmp    %r8,%rcx
je     123c <cota_vector+0x13c>
movaps 0xdef(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rcx,4),%xmm2
subss  (%rsi,%rcx,4),%xmm2
andps  %xmm1,%xmm2
movss  %xmm2,(%r9,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r8
jne    1220 <cota_vector+0x120>
test   %edx,%edx
jle    12d5 <cota_vector+0x1d5>
lea    -0x1(%r8),%rax
mov    %r8d,%ecx
and    $0x3,%ecx
cmp    $0x3,%rax
jae    125b <cota_vector+0x15b>
xorps  %xmm1,%xmm1
xor    %eax,%eax
jmp    12a4 <cota_vector+0x1a4>
and    $0xfffffffc,%r8d
xorps  %xmm1,%xmm1
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%r9,%rax,4),%xmm0
maxss  %xmm1,%xmm0
movss  0x4(%r9,%rax,4),%xmm1
maxss  %xmm0,%xmm1
movss  0x8(%r9,%rax,4),%xmm0
maxss  %xmm1,%xmm0
movss  0xc(%r9,%rax,4),%xmm1
maxss  %xmm0,%xmm1
add    $0x4,%rax
cmp    %rax,%r8
jne    1270 <cota_vector+0x170>
movaps %xmm1,%xmm0
test   %rcx,%rcx
je     12d5 <cota_vector+0x1d5>
lea    (%r9,%rax,4),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rax,%rdx,4),%xmm0
maxss  %xmm1,%xmm0
add    $0x1,%rdx
movaps %xmm0,%xmm1
cmp    %rdx,%rcx
jne    12c0 <cota_vector+0x1c0>
mov    %rbp,%rsp
pop    %rbp
ret
xor    %eax,%eax
test   $0x1,%r10b
jne    11d5 <cota_vector+0xd5>
jmp    1205 <cota_vector+0x105>

LLVM IR (-O0):
define float @cota_vector(float* %0, float* %1, i32 %2) {
%4 = alloca float*
%5 = alloca float*
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i64
%9 = alloca float
%10 = alloca i32
store float* %0, float** %4
store float* %1, float** %5
store i32 %2, i32* %6
%11 = load i32, i32* %6
%12 = zext i32 %11 to i64
%13 = call i8* @llvm.stacksave()
store i8* %13, i8** %7
%14 = alloca float, i64 %12
store i64 %12, i64* %8
store float 0.000000e+00, float* %9
store i32 0, i32* %10
br label %15
15: ; preds = %35, %3
%16 = load i32, i32* %10
%17 = load i32, i32* %6
%18 = icmp slt i32 %16, %17
br i1 %18, label %19, label %38
19: ; preds = %15
%20 = load float*, float** %4
%21 = load i32, i32* %10
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds float, float* %20, i64 %22
%24 = load float, float* %23
%25 = load float*, float** %5
%26 = load i32, i32* %10
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds float, float* %25, i64 %27
%29 = load float, float* %28
%30 = fsub float %24, %29
%31 = call float @fabs(float %30)
%32 = load i32, i32* %10
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds float, float* %14, i64 %33
store float %31, float* %34
br label %35
35: ; preds = %19
%36 = load i32, i32* %10
%37 = add nsw i32 %36, 1
store i32 %37, i32* %10
br label %15
38: ; preds = %15
store i32 0, i32* %10
br label %39
39: ; preds = %56, %38
%40 = load i32, i32* %10
%41 = load i32, i32* %6
%42 = icmp slt i32 %40, %41
br i1 %42, label %43, label %59
43: ; preds = %39
%44 = load i32, i32* %10
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds float, float* %14, i64 %45
%47 = load float, float* %46
%48 = load float, float* %9
%49 = fcmp ogt float %47, %48
br i1 %49, label %50, label %55
50: ; preds = %43
%51 = load i32, i32* %10
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds float, float* %14, i64 %52
%54 = load float, float* %53
store float %54, float* %9
br label %55
55: ; preds = %50, %43
br label %56
56: ; preds = %55
%57 = load i32, i32* %10
%58 = add nsw i32 %57, 1
store i32 %58, i32* %10
br label %39
59: ; preds = %39
%60 = load float, float* %9
%61 = load i8*, i8** %7
ret float %60
}

LLVM IR (-O2):
define float @cota_vector(float* nocapture %0, float* nocapture %1, i32 %2) {
%4 = zext i32 %2 to i64
%5 = alloca float, i64 %4
%6 = icmp sgt i32 %2, 0
br i1 %6, label %7, label %153
7: ; preds = %3
%8 = icmp ult i32 %2, 8
br i1 %8, label %91, label %9
9: ; preds = %7
%10 = and i64 %4, 4294967288
%11 = add nsw i64 %10, -8
%12 = lshr exact i64 %11, 3
%13 = add nuw nsw i64 %12, 1
%14 = and i64 %13, 1
%15 = icmp eq i64 %11, 0
br i1 %15, label %65, label %16
16: ; preds = %9
%17 = and i64 %13, 4611686018427387902
br label %18
18: ; preds = %18, %16
%19 = phi i64 [ 0, %16 ], [ %62, %18 ]
%20 = phi i64 [ 0, %16 ], [ %63, %18 ]
%21 = getelementptr inbounds float, float* %0, i64 %19
%22 = bitcast float* %21 to <4 x float>*
%23 = load <4 x float>, <4 x float>* %22
%24 = getelementptr inbounds float, float* %21, i64 4
%25 = bitcast float* %24 to <4 x float>*
%26 = load <4 x float>, <4 x float>* %25
%27 = getelementptr inbounds float, float* %1, i64 %19
%28 = bitcast float* %27 to <4 x float>*
%29 = load <4 x float>, <4 x float>* %28
%30 = getelementptr inbounds float, float* %27, i64 4
%31 = bitcast float* %30 to <4 x float>*
%32 = load <4 x float>, <4 x float>* %31
%33 = fsub <4 x float> %23, %29
%34 = fsub <4 x float> %26, %32
%35 = call <4 x float> @llvm.fabs.v4f32(<4 x float> %33)
%36 = call <4 x float> @llvm.fabs.v4f32(<4 x float> %34)
%37 = getelementptr inbounds float, float* %5, i64 %19
%38 = bitcast float* %37 to <4 x float>*
store <4 x float> %35, <4 x float>* %38
%39 = getelementptr inbounds float, float* %37, i64 4
%40 = bitcast float* %39 to <4 x float>*
store <4 x float> %36, <4 x float>* %40
%41 = or i64 %19, 8
%42 = getelementptr inbounds float, float* %0, i64 %41
%43 = bitcast float* %42 to <4 x float>*
%44 = load <4 x float>, <4 x float>* %43
%45 = getelementptr inbounds float, float* %42, i64 4
%46 = bitcast float* %45 to <4 x float>*
%47 = load <4 x float>, <4 x float>* %46
%48 = getelementptr inbounds float, float* %1, i64 %41
%49 = bitcast float* %48 to <4 x float>*
%50 = load <4 x float>, <4 x float>* %49
%51 = getelementptr inbounds float, float* %48, i64 4
%52 = bitcast float* %51 to <4 x float>*
%53 = load <4 x float>, <4 x float>* %52
%54 = fsub <4 x float> %44, %50
%55 = fsub <4 x float> %47, %53
%56 = call <4 x float> @llvm.fabs.v4f32(<4 x float> %54)
%57 = call <4 x float> @llvm.fabs.v4f32(<4 x float> %55)
%58 = getelementptr inbounds float, float* %5, i64 %41
%59 = bitcast float* %58 to <4 x float>*
store <4 x float> %56, <4 x float>* %59
%60 = getelementptr inbounds float, float* %58, i64 4
%61 = bitcast float* %60 to <4 x float>*
store <4 x float> %57, <4 x float>* %61
%62 = add nuw i64 %19, 16
%63 = add i64 %20, 2
%64 = icmp eq i64 %63, %17
br i1 %64, label %65, label %18
65: ; preds = %18, %9
%66 = phi i64 [ 0, %9 ], [ %62, %18 ]
%67 = icmp eq i64 %14, 0
br i1 %67, label %89, label %68
68: ; preds = %65
%69 = getelementptr inbounds float, float* %0, i64 %66
%70 = bitcast float* %69 to <4 x float>*
%71 = load <4 x float>, <4 x float>* %70
%72 = getelementptr inbounds float, float* %69, i64 4
%73 = bitcast float* %72 to <4 x float>*
%74 = load <4 x float>, <4 x float>* %73
%75 = getelementptr inbounds float, float* %1, i64 %66
%76 = bitcast float* %75 to <4 x float>*
%77 = load <4 x float>, <4 x float>* %76
%78 = getelementptr inbounds float, float* %75, i64 4
%79 = bitcast float* %78 to <4 x float>*
%80 = load <4 x float>, <4 x float>* %79
%81 = fsub <4 x float> %71, %77
%82 = fsub <4 x float> %74, %80
%83 = call <4 x float> @llvm.fabs.v4f32(<4 x float> %81)
%84 = call <4 x float> @llvm.fabs.v4f32(<4 x float> %82)
%85 = getelementptr inbounds float, float* %5, i64 %66
%86 = bitcast float* %85 to <4 x float>*
store <4 x float> %83, <4 x float>* %86
%87 = getelementptr inbounds float, float* %85, i64 4
%88 = bitcast float* %87 to <4 x float>*
store <4 x float> %84, <4 x float>* %88
br label %89
89: ; preds = %65, %68
%90 = icmp eq i64 %10, %4
br i1 %90, label %93, label %91
91: ; preds = %7, %89
%92 = phi i64 [ 0, %7 ], [ %10, %89 ]
br label %100
93: ; preds = %100, %89
br i1 %6, label %94, label %153
94: ; preds = %93
%95 = add nsw i64 %4, -1
%96 = and i64 %4, 3
%97 = icmp ult i64 %95, 3
br i1 %97, label %137, label %98
98: ; preds = %94
%99 = and i64 %4, 4294967292
br label %111
100: ; preds = %91, %100
%101 = phi i64 [ %109, %100 ], [ %92, %91 ]
%102 = getelementptr inbounds float, float* %0, i64 %101
%103 = load float, float* %102
%104 = getelementptr inbounds float, float* %1, i64 %101
%105 = load float, float* %104
%106 = fsub float %103, %105
%107 = tail call float @llvm.fabs.f32(float %106)
%108 = getelementptr inbounds float, float* %5, i64 %101
store float %107, float* %108
%109 = add nuw nsw i64 %101, 1
%110 = icmp eq i64 %109, %4
br i1 %110, label %93, label %100
111: ; preds = %111, %98
%112 = phi i64 [ 0, %98 ], [ %134, %111 ]
%113 = phi float [ 0.000000e+00, %98 ], [ %133, %111 ]
%114 = phi i64 [ 0, %98 ], [ %135, %111 ]
%115 = getelementptr inbounds float, float* %5, i64 %112
%116 = load float, float* %115
%117 = fcmp ogt float %116, %113
%118 = select i1 %117, float %116, float %113
%119 = or i64 %112, 1
%120 = getelementptr inbounds float, float* %5, i64 %119
%121 = load float, float* %120
%122 = fcmp ogt float %121, %118
%123 = select i1 %122, float %121, float %118
%124 = or i64 %112, 2
%125 = getelementptr inbounds float, float* %5, i64 %124
%126 = load float, float* %125
%127 = fcmp ogt float %126, %123
%128 = select i1 %127, float %126, float %123
%129 = or i64 %112, 3
%130 = getelementptr inbounds float, float* %5, i64 %129
%131 = load float, float* %130
%132 = fcmp ogt float %131, %128
%133 = select i1 %132, float %131, float %128
%134 = add nuw nsw i64 %112, 4
%135 = add i64 %114, 4
%136 = icmp eq i64 %135, %99
br i1 %136, label %137, label %111
137: ; preds = %111, %94
%138 = phi float [ undef, %94 ], [ %133, %111 ]
%139 = phi i64 [ 0, %94 ], [ %134, %111 ]
%140 = phi float [ 0.000000e+00, %94 ], [ %133, %111 ]
%141 = icmp eq i64 %96, 0
br i1 %141, label %153, label %142
142: ; preds = %137, %142
%143 = phi i64 [ %150, %142 ], [ %139, %137 ]
%144 = phi float [ %149, %142 ], [ %140, %137 ]
%145 = phi i64 [ %151, %142 ], [ 0, %137 ]
%146 = getelementptr inbounds float, float* %5, i64 %143
%147 = load float, float* %146
%148 = fcmp ogt float %147, %144
%149 = select i1 %148, float %147, float %144
%150 = add nuw nsw i64 %143, 1
%151 = add i64 %145, 1
%152 = icmp eq i64 %151, %96
br i1 %152, label %153, label %142
153: ; preds = %137, %142, %3, %93
%154 = phi float [ 0.000000e+00, %93 ], [ 0.000000e+00, %3 ], [ %138, %137 ], [ %149, %142 ]
ret float %154
}