#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 */
double computarOperacao(char operacao, double matriz[][12]) {
  double soma = 0;
  size_t i, j, posicoesSomadas = 0;
  for (i = 0; i < 12; i++) {
    for (j = 0; j < 12 - i - 1; j++) {
      soma += matriz[i][j];
      posicoesSomadas++;
    }
  }
  if (operacao == 'S') {
    return soma;
  } else {
    return soma / posicoesSomadas;
  }
}


x86 assembly (clang, -O0):
<computarOperacao>:
push   %rbp
mov    %rsp,%rbp
mov    %dil,%al
mov    %al,-0x9(%rbp)
mov    %rsi,-0x18(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x28(%rbp)
cmpq   $0xc,-0x28(%rbp)
jae    11a5 <computarOperacao+0xa5>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    $0xc,%ecx
sub    -0x28(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jae    118f <computarOperacao+0x8f>
mov    -0x18(%rbp),%rax
imul   $0x60,-0x28(%rbp),%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1139 <computarOperacao+0x39>
jmp    1194 <computarOperacao+0x94>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1126 <computarOperacao+0x26>
movsbl -0x9(%rbp),%eax
cmp    $0x53,%eax
jne    11c1 <computarOperacao+0xc1>
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    11f6 <computarOperacao+0xf6>
movsd  -0x20(%rbp),%xmm0
movaps 0xe33(%rip),%xmm2
movq   -0x38(%rbp),%xmm1
punpckldq %xmm2,%xmm1
movapd 0xe32(%rip),%xmm2
subpd  %xmm2,%xmm1
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<computarOperacao>:
push   %r14
push   %rbx
lea    0x18(%rsi),%rcx
xorpd  %xmm0,%xmm0
mov    $0xb,%r10d
xor    %r9d,%r9d
mov    $0x1,%r8d
xor    %r11d,%r11d
jmp    113d <computarOperacao+0x3d>
nop
add    %r14,%r9
add    $0x1,%r11
add    $0xffffffffffffffff,%r10
add    $0x60,%rcx
add    $0x60,%rsi
cmp    $0xc,%r11
je     11d3 <computarOperacao+0xd3>
cmp    $0x2,%r10
mov    $0x1,%r14d
cmovae %r10,%r14
lea    -0xb(%r11),%rax
neg    %rax
cmp    $0x2,%rax
cmovb  %r8,%rax
cmp    $0xb,%r11
je     11d3 <computarOperacao+0xd3>
lea    -0x1(%rax),%rdx
cmp    $0x3,%rdx
jae    1170 <computarOperacao+0x70>
xor    %ebx,%ebx
jmp    11a0 <computarOperacao+0xa0>
xchg   %ax,%ax
mov    %r14,%rdx
and    $0xfffffffffffffffc,%rdx
xor    %ebx,%ebx
nopl   0x0(%rax)
addsd  -0x18(%rcx,%rbx,8),%xmm0
addsd  -0x10(%rcx,%rbx,8),%xmm0
addsd  -0x8(%rcx,%rbx,8),%xmm0
addsd  (%rcx,%rbx,8),%xmm0
add    $0x4,%rbx
cmp    %rbx,%rdx
jne    1180 <computarOperacao+0x80>
test   $0x3,%al
je     1120 <computarOperacao+0x20>
mov    %r14d,%eax
and    $0x3,%eax
lea    (%rsi,%rbx,8),%rdx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
addsd  (%rdx,%rbx,8),%xmm0
add    $0x1,%rbx
cmp    %rbx,%rax
jne    11c0 <computarOperacao+0xc0>
jmp    1120 <computarOperacao+0x20>
cmp    $0x53,%dil
je     11fe <computarOperacao+0xfe>
movq   %r9,%xmm1
punpckldq 0xe1a(%rip),%xmm1
subpd  0xe22(%rip),%xmm1
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
addsd  %xmm1,%xmm2
divsd  %xmm2,%xmm0
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define double @computarOperacao(i8 signext %0, [12 x double]* %1) {
%3 = alloca double
%4 = alloca i8
%5 = alloca [12 x double]*
%6 = alloca double
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
store i8 %0, i8* %4
store [12 x double]* %1, [12 x double]** %5
store double 0.000000e+00, double* %6
store i64 0, i64* %9
store i64 0, i64* %7
br label %10
10: ; preds = %35, %2
%11 = load i64, i64* %7
%12 = icmp ult i64 %11, 12
br i1 %12, label %13, label %38
13: ; preds = %10
store i64 0, i64* %8
br label %14
14: ; preds = %31, %13
%15 = load i64, i64* %8
%16 = load i64, i64* %7
%17 = sub i64 12, %16
%18 = sub i64 %17, 1
%19 = icmp ult i64 %15, %18
br i1 %19, label %20, label %34
20: ; preds = %14
%21 = load [12 x double]*, [12 x double]** %5
%22 = load i64, i64* %7
%23 = getelementptr inbounds [12 x double], [12 x double]* %21, i64 %22
%24 = load i64, i64* %8
%25 = getelementptr inbounds [12 x double], [12 x double]* %23, i64 0, i64 %24
%26 = load double, double* %25
%27 = load double, double* %6
%28 = fadd double %27, %26
store double %28, double* %6
%29 = load i64, i64* %9
%30 = add i64 %29, 1
store i64 %30, i64* %9
br label %31
31: ; preds = %20
%32 = load i64, i64* %8
%33 = add i64 %32, 1
store i64 %33, i64* %8
br label %14
34: ; preds = %14
br label %35
35: ; preds = %34
%36 = load i64, i64* %7
%37 = add i64 %36, 1
store i64 %37, i64* %7
br label %10
38: ; preds = %10
%39 = load i8, i8* %4
%40 = sext i8 %39 to i32
%41 = icmp eq i32 %40, 83
br i1 %41, label %42, label %44
42: ; preds = %38
%43 = load double, double* %6
store double %43, double* %3
br label %49
44: ; preds = %38
%45 = load double, double* %6
%46 = load i64, i64* %9
%47 = uitofp i64 %46 to double
%48 = fdiv double %45, %47
store double %48, double* %3
br label %49
49: ; preds = %44, %42
%50 = load double, double* %3
ret double %50
}

LLVM IR (-O2):
define double @computarOperacao(i8 signext %0, [12 x double]* nocapture %1) {
br label %3
3: ; preds = %2, %55
%4 = phi i64 [ 11, %2 ], [ %59, %55 ]
%5 = phi i64 [ 0, %2 ], [ %57, %55 ]
%6 = phi i64 [ 0, %2 ], [ %58, %55 ]
%7 = phi double [ 0.000000e+00, %2 ], [ %56, %55 ]
%8 = sub nsw i64 11, %6
%9 = call i64 @llvm.umax.i64(i64 %8, i64 1)
%10 = call i64 @llvm.umax.i64(i64 %4, i64 1)
%11 = icmp eq i64 %6, 11
br i1 %11, label %61, label %12
12: ; preds = %3
%13 = add nsw i64 %9, -1
%14 = and i64 %9, 3
%15 = icmp ult i64 %13, 3
br i1 %15, label %40, label %16
16: ; preds = %12
%17 = and i64 %9, -4
br label %18
18: ; preds = %18, %16
%19 = phi i64 [ 0, %16 ], [ %37, %18 ]
%20 = phi double [ %7, %16 ], [ %36, %18 ]
%21 = phi i64 [ 0, %16 ], [ %38, %18 ]
%22 = getelementptr inbounds [12 x double], [12 x double]* %1, i64 %6, i64 %19
%23 = load double, double* %22
%24 = fadd double %20, %23
%25 = or i64 %19, 1
%26 = getelementptr inbounds [12 x double], [12 x double]* %1, i64 %6, i64 %25
%27 = load double, double* %26
%28 = fadd double %24, %27
%29 = or i64 %19, 2
%30 = getelementptr inbounds [12 x double], [12 x double]* %1, i64 %6, i64 %29
%31 = load double, double* %30
%32 = fadd double %28, %31
%33 = or i64 %19, 3
%34 = getelementptr inbounds [12 x double], [12 x double]* %1, i64 %6, i64 %33
%35 = load double, double* %34
%36 = fadd double %32, %35
%37 = add nuw nsw i64 %19, 4
%38 = add i64 %21, 4
%39 = icmp eq i64 %38, %17
br i1 %39, label %40, label %18
40: ; preds = %18, %12
%41 = phi double [ undef, %12 ], [ %36, %18 ]
%42 = phi i64 [ 0, %12 ], [ %37, %18 ]
%43 = phi double [ %7, %12 ], [ %36, %18 ]
%44 = icmp eq i64 %14, 0
br i1 %44, label %55, label %45
45: ; preds = %40, %45
%46 = phi i64 [ %52, %45 ], [ %42, %40 ]
%47 = phi double [ %51, %45 ], [ %43, %40 ]
%48 = phi i64 [ %53, %45 ], [ 0, %40 ]
%49 = getelementptr inbounds [12 x double], [12 x double]* %1, i64 %6, i64 %46
%50 = load double, double* %49
%51 = fadd double %47, %50
%52 = add nuw nsw i64 %46, 1
%53 = add i64 %48, 1
%54 = icmp eq i64 %53, %14
br i1 %54, label %55, label %45
55: ; preds = %45, %40
%56 = phi double [ %41, %40 ], [ %51, %45 ]
%57 = add i64 %5, %10
%58 = add nuw nsw i64 %6, 1
%59 = add nsw i64 %4, -1
%60 = icmp eq i64 %58, 12
br i1 %60, label %61, label %3
61: ; preds = %3, %55
%62 = phi i64 [ %57, %55 ], [ %5, %3 ]
%63 = phi double [ %56, %55 ], [ %7, %3 ]
%64 = icmp eq i8 %0, 83
br i1 %64, label %68, label %65
65: ; preds = %61
%66 = uitofp i64 %62 to double
%67 = fdiv double %63, %66
br label %68
68: ; preds = %61, %65
%69 = phi double [ %67, %65 ], [ %63, %61 ]
ret double %69
}