#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 Encuentra_Maximo(int, float *);
int multrnd(int, float *, int);
float sump(int, float *);
int Find_action(int n, float p[30], float ep, int inc) {
  int index, i, at;
  float PSum;
  float newp[30];
  index = Encuentra_Maximo(n, p);
  PSum = sump(n, p);
  for (i = 0; i < n; i++) {
    newp[i] = (ep / n);
  }
  newp[index] = 1 - (n - 1) * (ep / n);
  at = multrnd(n, newp, inc);
  return at;
}


x86 assembly (clang, -O0):
<Find_action>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rsi
call   1030 <Encuentra_Maximo@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rsi
call   1050 <sump@plt>
movss  %xmm0,-0x28(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11a6 <Find_action+0x76>
movss  -0x14(%rbp),%xmm0
cvtsi2ssl -0x4(%rbp),%xmm1
divss  %xmm1,%xmm0
movslq -0x20(%rbp),%rax
movss  %xmm0,-0xa0(%rbp,%rax,4)
ff ff
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1171 <Find_action+0x41>
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  -0x14(%rbp),%xmm1
cvtsi2ssl -0x4(%rbp),%xmm2
divss  %xmm2,%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm1,%xmm0
movss  0xe29(%rip),%xmm1
addss  %xmm1,%xmm0
movslq -0x1c(%rbp),%rax
movss  %xmm0,-0xa0(%rbp,%rax,4)
ff ff
mov    -0x4(%rbp),%edi
lea    -0xa0(%rbp),%rsi
mov    -0x18(%rbp),%edx
call   1040 <multrnd@plt>
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Find_action>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x98,%rsp
mov    %edx,%r14d
movaps %xmm0,0x80(%rsp)
mov    %rsi,%rbp
mov    %edi,%ebx
call   1030 <Encuentra_Maximo@plt>
mov    %eax,%r15d
mov    %ebx,%edi
mov    %rbp,%rsi
call   1050 <sump@plt>
movaps 0x80(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
divss  %xmm0,%xmm1
test   %ebx,%ebx
jle    127e <Find_action+0x14e>
mov    %ebx,%eax
cmp    $0x8,%ebx
jae    1188 <Find_action+0x58>
xor    %ecx,%ecx
jmp    1270 <Find_action+0x140>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
movaps %xmm1,%xmm0
shufps $0x0,%xmm1,%xmm0
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x7,%edx
cmp    $0x38,%rdi
jae    11b5 <Find_action+0x85>
xor    %edi,%edi
jmp    1231 <Find_action+0x101>
and    $0xfffffffffffffff8,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movaps %xmm0,(%rsp,%rdi,4)
movaps %xmm0,0x10(%rsp,%rdi,4)
movaps %xmm0,0x20(%rsp,%rdi,4)
movaps %xmm0,0x30(%rsp,%rdi,4)
movaps %xmm0,0x40(%rsp,%rdi,4)
movaps %xmm0,0x50(%rsp,%rdi,4)
movaps %xmm0,0x60(%rsp,%rdi,4)
movaps %xmm0,0x70(%rsp,%rdi,4)
movaps %xmm0,0x80(%rsp,%rdi,4)
movaps %xmm0,0x90(%rsp,%rdi,4)
movaps %xmm0,0xa0(%rsp,%rdi,4)
movaps %xmm0,0xb0(%rsp,%rdi,4)
movaps %xmm0,0xc0(%rsp,%rdi,4)
movaps %xmm0,0xd0(%rsp,%rdi,4)
movaps %xmm0,0xe0(%rsp,%rdi,4)
movaps %xmm0,0xf0(%rsp,%rdi,4)
add    $0x40,%rdi
add    $0xfffffffffffffff8,%rsi
jne    11c0 <Find_action+0x90>
test   %rdx,%rdx
je     1262 <Find_action+0x132>
lea    (%rsp,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movaps %xmm0,-0x10(%rsi,%rdi,1)
movaps %xmm0,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1250 <Find_action+0x120>
cmp    %rax,%rcx
je     127e <Find_action+0x14e>
nopw   0x0(%rax,%rax,1)
movss  %xmm1,(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1270 <Find_action+0x140>
lea    -0x1(%rbx),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  %xmm1,%xmm0
movss  0xd6c(%rip),%xmm1
subss  %xmm0,%xmm1
movslq %r15d,%rax
movss  %xmm1,(%rsp,%rax,4)
mov    %rsp,%rsi
mov    %ebx,%edi
mov    %r14d,%edx
call   1040 <multrnd@plt>
add    $0x98,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @Find_action(i32 %0, float* %1, float %2, i32 %3) {
%5 = alloca i32
%6 = alloca float*
%7 = alloca float
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca float
%13 = alloca [30 x float]
store i32 %0, i32* %5
store float* %1, float** %6
store float %2, float* %7
store i32 %3, i32* %8
%14 = load i32, i32* %5
%15 = load float*, float** %6
%16 = call i32 @Encuentra_Maximo(i32 %14, float* %15)
store i32 %16, i32* %9
%17 = load i32, i32* %5
%18 = load float*, float** %6
%19 = call float @sump(i32 %17, float* %18)
store float %19, float* %12
store i32 0, i32* %10
br label %20
20: ; preds = %32, %4
%21 = load i32, i32* %10
%22 = load i32, i32* %5
%23 = icmp slt i32 %21, %22
br i1 %23, label %24, label %35
24: ; preds = %20
%25 = load float, float* %7
%26 = load i32, i32* %5
%27 = sitofp i32 %26 to float
%28 = fdiv float %25, %27
%29 = load i32, i32* %10
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds [30 x float], [30 x float]* %13, i64 0, i64 %30
store float %28, float* %31
br label %32
32: ; preds = %24
%33 = load i32, i32* %10
%34 = add nsw i32 %33, 1
store i32 %34, i32* %10
br label %20
35: ; preds = %20
%36 = load i32, i32* %5
%37 = sub nsw i32 %36, 1
%38 = sitofp i32 %37 to float
%39 = load float, float* %7
%40 = load i32, i32* %5
%41 = sitofp i32 %40 to float
%42 = fdiv float %39, %41
%43 = fneg float %38
%44 = call float @llvm.fmuladd.f32(float %43, float %42, float 1.000000e+00)
%45 = load i32, i32* %9
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [30 x float], [30 x float]* %13, i64 0, i64 %46
store float %44, float* %47
%48 = load i32, i32* %5
%49 = getelementptr inbounds [30 x float], [30 x float]* %13, i64 0, i64 0
%50 = load i32, i32* %8
%51 = call i32 @multrnd(i32 %48, float* %49, i32 %50)
store i32 %51, i32* %11
%52 = load i32, i32* %11
ret i32 %52
}

LLVM IR (-O2):
define i32 @Find_action(i32 %0, float* %1, float %2, i32 %3) {
%5 = alloca [30 x float]
%6 = bitcast [30 x float]* %5 to i8*
%7 = tail call i32 @Encuentra_Maximo(i32 %0, float* %1)
%8 = tail call float @sump(i32 %0, float* %1)
%9 = icmp sgt i32 %0, 0
%10 = sitofp i32 %0 to float
%11 = fdiv float %2, %10
br i1 %9, label %12, label %95
12: ; preds = %4
%13 = zext i32 %0 to i64
%14 = icmp ult i32 %0, 8
br i1 %14, label %88, label %15
15: ; preds = %12
%16 = and i64 %13, 4294967288
%17 = insertelement <4 x float> poison, float %11, i64 0
%18 = shufflevector <4 x float> %17, <4 x float> poison, <4 x i32> zeroinitializer
%19 = insertelement <4 x float> poison, float %11, i64 0
%20 = shufflevector <4 x float> %19, <4 x float> poison, <4 x i32> zeroinitializer
%21 = add nsw i64 %16, -8
%22 = lshr exact i64 %21, 3
%23 = add nuw nsw i64 %22, 1
%24 = and i64 %23, 7
%25 = icmp ult i64 %21, 56
br i1 %25, label %73, label %26
26: ; preds = %15
%27 = and i64 %23, 4611686018427387896
br label %28
28: ; preds = %28, %26
%29 = phi i64 [ 0, %26 ], [ %70, %28 ]
%30 = phi i64 [ 0, %26 ], [ %71, %28 ]
%31 = getelementptr inbounds [30 x float], [30 x float]* %5, i64 0, i64 %29
%32 = bitcast float* %31 to <4 x float>*
store <4 x float> %18, <4 x float>* %32
%33 = getelementptr inbounds float, float* %31, i64 4
%34 = bitcast float* %33 to <4 x float>*
store <4 x float> %20, <4 x float>* %34
%35 = or i64 %29, 8
%36 = getelementptr inbounds [30 x float], [30 x float]* %5, i64 0, i64 %35
%37 = bitcast float* %36 to <4 x float>*
store <4 x float> %18, <4 x float>* %37
%38 = getelementptr inbounds float, float* %36, i64 4
%39 = bitcast float* %38 to <4 x float>*
store <4 x float> %20, <4 x float>* %39
%40 = or i64 %29, 16
%41 = getelementptr inbounds [30 x float], [30 x float]* %5, i64 0, i64 %40
%42 = bitcast float* %41 to <4 x float>*
store <4 x float> %18, <4 x float>* %42
%43 = getelementptr inbounds float, float* %41, i64 4
%44 = bitcast float* %43 to <4 x float>*
store <4 x float> %20, <4 x float>* %44
%45 = or i64 %29, 24
%46 = getelementptr inbounds [30 x float], [30 x float]* %5, i64 0, i64 %45
%47 = bitcast float* %46 to <4 x float>*
store <4 x float> %18, <4 x float>* %47
%48 = getelementptr inbounds float, float* %46, i64 4
%49 = bitcast float* %48 to <4 x float>*
store <4 x float> %20, <4 x float>* %49
%50 = or i64 %29, 32
%51 = getelementptr inbounds [30 x float], [30 x float]* %5, i64 0, i64 %50
%52 = bitcast float* %51 to <4 x float>*
store <4 x float> %18, <4 x float>* %52
%53 = getelementptr inbounds float, float* %51, i64 4
%54 = bitcast float* %53 to <4 x float>*
store <4 x float> %20, <4 x float>* %54
%55 = or i64 %29, 40
%56 = getelementptr inbounds [30 x float], [30 x float]* %5, i64 0, i64 %55
%57 = bitcast float* %56 to <4 x float>*
store <4 x float> %18, <4 x float>* %57
%58 = getelementptr inbounds float, float* %56, i64 4
%59 = bitcast float* %58 to <4 x float>*
store <4 x float> %20, <4 x float>* %59
%60 = or i64 %29, 48
%61 = getelementptr inbounds [30 x float], [30 x float]* %5, i64 0, i64 %60
%62 = bitcast float* %61 to <4 x float>*
store <4 x float> %18, <4 x float>* %62
%63 = getelementptr inbounds float, float* %61, i64 4
%64 = bitcast float* %63 to <4 x float>*
store <4 x float> %20, <4 x float>* %64
%65 = or i64 %29, 56
%66 = getelementptr inbounds [30 x float], [30 x float]* %5, i64 0, i64 %65
%67 = bitcast float* %66 to <4 x float>*
store <4 x float> %18, <4 x float>* %67
%68 = getelementptr inbounds float, float* %66, i64 4
%69 = bitcast float* %68 to <4 x float>*
store <4 x float> %20, <4 x float>* %69
%70 = add nuw i64 %29, 64
%71 = add nuw i64 %30, 8
%72 = icmp eq i64 %71, %27
br i1 %72, label %73, label %28
73: ; preds = %28, %15
%74 = phi i64 [ 0, %15 ], [ %70, %28 ]
%75 = icmp eq i64 %24, 0
br i1 %75, label %86, label %76
76: ; preds = %73, %76
%77 = phi i64 [ %83, %76 ], [ %74, %73 ]
%78 = phi i64 [ %84, %76 ], [ 0, %73 ]
%79 = getelementptr inbounds [30 x float], [30 x float]* %5, i64 0, i64 %77
%80 = bitcast float* %79 to <4 x float>*
store <4 x float> %18, <4 x float>* %80
%81 = getelementptr inbounds float, float* %79, i64 4
%82 = bitcast float* %81 to <4 x float>*
store <4 x float> %20, <4 x float>* %82
%83 = add nuw i64 %77, 8
%84 = add i64 %78, 1
%85 = icmp eq i64 %84, %24
br i1 %85, label %86, label %76
86: ; preds = %76, %73
%87 = icmp eq i64 %16, %13
br i1 %87, label %95, label %88
88: ; preds = %12, %86
%89 = phi i64 [ 0, %12 ], [ %16, %86 ]
br label %90
90: ; preds = %88, %90
%91 = phi i64 [ %93, %90 ], [ %89, %88 ]
%92 = getelementptr inbounds [30 x float], [30 x float]* %5, i64 0, i64 %91
store float %11, float* %92
%93 = add nuw nsw i64 %91, 1
%94 = icmp eq i64 %93, %13
br i1 %94, label %95, label %90
95: ; preds = %90, %86, %4
%96 = add nsw i32 %0, -1
%97 = sitofp i32 %96 to float
%98 = fneg float %97
%99 = tail call float @llvm.fmuladd.f32(float %98, float %11, float 1.000000e+00)
%100 = sext i32 %7 to i64
%101 = getelementptr inbounds [30 x float], [30 x float]* %5, i64 0, i64 %100
store float %99, float* %101
%102 = getelementptr inbounds [30 x float], [30 x float]* %5, i64 0, i64 0
%103 = call i32 @multrnd(i32 %0, float* %102, i32 %3)
ret i32 %103
}