#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*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ stdout;
void mostrar_resultado(float gano[12][2]) {
  int mes;
  fprintf(stdout, "MES |enA    |enB    |total\n"
                  "----+-------+-------+-------\n");
  for (mes = 0; mes < 12; mes = mes + 1) {
    fprintf(stdout, "  %2d|%7.2f|%7.2f|%7.2f\n", mes + 1, gano[mes][0],
            gano[mes][1], gano[mes][0] + gano[mes][1]);
  }
}


x86 assembly (clang, -O0):
<mostrar_resultado>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    0x2ebd(%rip),%rax
mov    (%rax),%edi
lea    0xed4(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
movl   $0x0,-0xc(%rbp)
cmpl   $0xc,-0xc(%rbp)
jge    11b1 <mostrar_resultado+0xa1>
mov    0x2e95(%rip),%rax
mov    (%rax),%edi
mov    -0xc(%rbp),%edx
add    $0x1,%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
addss  0x4(%rax,%rcx,8),%xmm2
cvtss2sd %xmm2,%xmm2
lea    0xe9d(%rip),%rsi
mov    $0x3,%al
call   1030 <fprintf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    113a <mostrar_resultado+0x2a>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mostrar_resultado>:
push   %r15
push   %r14
push   %rbx
mov    %rdi,%rbx
mov    0x2ec1(%rip),%r15
mov    (%r15),%edi
lea    0xed7(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%r15),%edi
movss  (%rbx),%xmm2
movss  0x4(%rbx),%xmm3
cvtss2sd %xmm2,%xmm0
cvtss2sd %xmm3,%xmm1
addss  %xmm3,%xmm2
cvtss2sd %xmm2,%xmm2
lea    0xee6(%rip),%r14
mov    %r14,%rsi
mov    $0x1,%edx
mov    $0x3,%al
call   1030 <fprintf@plt>
mov    (%r15),%edi
movss  0x8(%rbx),%xmm2
movss  0xc(%rbx),%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
addss  %xmm3,%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r14,%rsi
mov    $0x2,%edx
mov    $0x3,%al
call   1030 <fprintf@plt>
mov    (%r15),%edi
movss  0x10(%rbx),%xmm2
movss  0x14(%rbx),%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
addss  %xmm3,%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r14,%rsi
mov    $0x3,%edx
mov    $0x3,%al
call   1030 <fprintf@plt>
mov    (%r15),%edi
movss  0x18(%rbx),%xmm2
movss  0x1c(%rbx),%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
addss  %xmm3,%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r14,%rsi
mov    $0x4,%edx
mov    $0x3,%al
call   1030 <fprintf@plt>
mov    (%r15),%edi
movss  0x20(%rbx),%xmm2
movss  0x24(%rbx),%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
addss  %xmm3,%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r14,%rsi
mov    $0x5,%edx
mov    $0x3,%al
call   1030 <fprintf@plt>
mov    (%r15),%edi
movss  0x28(%rbx),%xmm2
movss  0x2c(%rbx),%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
addss  %xmm3,%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r14,%rsi
mov    $0x6,%edx
mov    $0x3,%al
call   1030 <fprintf@plt>
mov    (%r15),%edi
movss  0x30(%rbx),%xmm2
movss  0x34(%rbx),%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
addss  %xmm3,%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r14,%rsi
mov    $0x7,%edx
mov    $0x3,%al
call   1030 <fprintf@plt>
mov    (%r15),%edi
movss  0x38(%rbx),%xmm2
movss  0x3c(%rbx),%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
addss  %xmm3,%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r14,%rsi
mov    $0x8,%edx
mov    $0x3,%al
call   1030 <fprintf@plt>
mov    (%r15),%edi
movss  0x40(%rbx),%xmm2
movss  0x44(%rbx),%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
addss  %xmm3,%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r14,%rsi
mov    $0x9,%edx
mov    $0x3,%al
call   1030 <fprintf@plt>
mov    (%r15),%edi
movss  0x48(%rbx),%xmm2
movss  0x4c(%rbx),%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
addss  %xmm3,%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r14,%rsi
mov    $0xa,%edx
mov    $0x3,%al
call   1030 <fprintf@plt>
mov    (%r15),%edi
movss  0x50(%rbx),%xmm2
movss  0x54(%rbx),%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
addss  %xmm3,%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r14,%rsi
mov    $0xb,%edx
mov    $0x3,%al
call   1030 <fprintf@plt>
mov    (%r15),%edi
movss  0x58(%rbx),%xmm2
movss  0x5c(%rbx),%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
addss  %xmm3,%xmm2
cvtss2sd %xmm2,%xmm2
mov    %r14,%rsi
mov    $0xc,%edx
mov    $0x3,%al
pop    %rbx
pop    %r14
pop    %r15
jmp    1030 <fprintf@plt>

LLVM IR (-O0):
@stdout = global i32 0
@.str = [57 x i8] c"MES |enA |enB |total\0A----+-------+-------+-------\0A\00"
@.str.1 = [25 x i8] c" %2d|%7.2f|%7.2f|%7.2f\0A\00"
define void @mostrar_resultado([2 x float]* %0) {
%2 = alloca [2 x float]*
%3 = alloca i32
store [2 x float]* %0, [2 x float]** %2
%4 = load i32, i32* @stdout
%5 = call i32 (i32, i8*, ...) @fprintf(i32 %4, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %3
br label %6
6: ; preds = %42, %1
%7 = load i32, i32* %3
%8 = icmp slt i32 %7, 12
br i1 %8, label %9, label %45
9: ; preds = %6
%10 = load i32, i32* @stdout
%11 = load i32, i32* %3
%12 = add nsw i32 %11, 1
%13 = load [2 x float]*, [2 x float]** %2
%14 = load i32, i32* %3
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds [2 x float], [2 x float]* %13, i64 %15
%17 = getelementptr inbounds [2 x float], [2 x float]* %16, i64 0, i64 0
%18 = load float, float* %17
%19 = fpext float %18 to double
%20 = load [2 x float]*, [2 x float]** %2
%21 = load i32, i32* %3
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds [2 x float], [2 x float]* %20, i64 %22
%24 = getelementptr inbounds [2 x float], [2 x float]* %23, i64 0, i64 1
%25 = load float, float* %24
%26 = fpext float %25 to double
%27 = load [2 x float]*, [2 x float]** %2
%28 = load i32, i32* %3
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [2 x float], [2 x float]* %27, i64 %29
%31 = getelementptr inbounds [2 x float], [2 x float]* %30, i64 0, i64 0
%32 = load float, float* %31
%33 = load [2 x float]*, [2 x float]** %2
%34 = load i32, i32* %3
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 %35
%37 = getelementptr inbounds [2 x float], [2 x float]* %36, i64 0, i64 1
%38 = load float, float* %37
%39 = fadd float %32, %38
%40 = fpext float %39 to double
%41 = call i32 (i32, i8*, ...) @fprintf(i32 %10, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0), i32 %12, double %19, double %26, double %40)
br label %42
42: ; preds = %9
%43 = load i32, i32* %3
%44 = add nsw i32 %43, 1
store i32 %44, i32* %3
br label %6
45: ; preds = %6
ret void
}

LLVM IR (-O2):
@stdout = global i32 0
@.str = [57 x i8] c"MES |enA |enB |total\0A----+-------+-------+-------\0A\00"
@.str.1 = [25 x i8] c" %2d|%7.2f|%7.2f|%7.2f\0A\00"
define void @mostrar_resultado([2 x float]* nocapture %0) {
%2 = load i32, i32* @stdout
%3 = tail call i32 (i32, i8*, ...) @fprintf(i32 %2, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str, i64 0, i64 0))
%4 = load i32, i32* @stdout
%5 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 0, i64 0
%6 = load float, float* %5
%7 = fpext float %6 to double
%8 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 0, i64 1
%9 = load float, float* %8
%10 = fpext float %9 to double
%11 = fadd float %6, %9
%12 = fpext float %11 to double
%13 = tail call i32 (i32, i8*, ...) @fprintf(i32 %4, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0), i32 1, double %7, double %10, double %12)
%14 = load i32, i32* @stdout
%15 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 1, i64 0
%16 = load float, float* %15
%17 = fpext float %16 to double
%18 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 1, i64 1
%19 = load float, float* %18
%20 = fpext float %19 to double
%21 = fadd float %16, %19
%22 = fpext float %21 to double
%23 = tail call i32 (i32, i8*, ...) @fprintf(i32 %14, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0), i32 2, double %17, double %20, double %22)
%24 = load i32, i32* @stdout
%25 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 2, i64 0
%26 = load float, float* %25
%27 = fpext float %26 to double
%28 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 2, i64 1
%29 = load float, float* %28
%30 = fpext float %29 to double
%31 = fadd float %26, %29
%32 = fpext float %31 to double
%33 = tail call i32 (i32, i8*, ...) @fprintf(i32 %24, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0), i32 3, double %27, double %30, double %32)
%34 = load i32, i32* @stdout
%35 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 3, i64 0
%36 = load float, float* %35
%37 = fpext float %36 to double
%38 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 3, i64 1
%39 = load float, float* %38
%40 = fpext float %39 to double
%41 = fadd float %36, %39
%42 = fpext float %41 to double
%43 = tail call i32 (i32, i8*, ...) @fprintf(i32 %34, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0), i32 4, double %37, double %40, double %42)
%44 = load i32, i32* @stdout
%45 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 4, i64 0
%46 = load float, float* %45
%47 = fpext float %46 to double
%48 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 4, i64 1
%49 = load float, float* %48
%50 = fpext float %49 to double
%51 = fadd float %46, %49
%52 = fpext float %51 to double
%53 = tail call i32 (i32, i8*, ...) @fprintf(i32 %44, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0), i32 5, double %47, double %50, double %52)
%54 = load i32, i32* @stdout
%55 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 5, i64 0
%56 = load float, float* %55
%57 = fpext float %56 to double
%58 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 5, i64 1
%59 = load float, float* %58
%60 = fpext float %59 to double
%61 = fadd float %56, %59
%62 = fpext float %61 to double
%63 = tail call i32 (i32, i8*, ...) @fprintf(i32 %54, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0), i32 6, double %57, double %60, double %62)
%64 = load i32, i32* @stdout
%65 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 6, i64 0
%66 = load float, float* %65
%67 = fpext float %66 to double
%68 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 6, i64 1
%69 = load float, float* %68
%70 = fpext float %69 to double
%71 = fadd float %66, %69
%72 = fpext float %71 to double
%73 = tail call i32 (i32, i8*, ...) @fprintf(i32 %64, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0), i32 7, double %67, double %70, double %72)
%74 = load i32, i32* @stdout
%75 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 7, i64 0
%76 = load float, float* %75
%77 = fpext float %76 to double
%78 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 7, i64 1
%79 = load float, float* %78
%80 = fpext float %79 to double
%81 = fadd float %76, %79
%82 = fpext float %81 to double
%83 = tail call i32 (i32, i8*, ...) @fprintf(i32 %74, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0), i32 8, double %77, double %80, double %82)
%84 = load i32, i32* @stdout
%85 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 8, i64 0
%86 = load float, float* %85
%87 = fpext float %86 to double
%88 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 8, i64 1
%89 = load float, float* %88
%90 = fpext float %89 to double
%91 = fadd float %86, %89
%92 = fpext float %91 to double
%93 = tail call i32 (i32, i8*, ...) @fprintf(i32 %84, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0), i32 9, double %87, double %90, double %92)
%94 = load i32, i32* @stdout
%95 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 9, i64 0
%96 = load float, float* %95
%97 = fpext float %96 to double
%98 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 9, i64 1
%99 = load float, float* %98
%100 = fpext float %99 to double
%101 = fadd float %96, %99
%102 = fpext float %101 to double
%103 = tail call i32 (i32, i8*, ...) @fprintf(i32 %94, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0), i32 10, double %97, double %100, double %102)
%104 = load i32, i32* @stdout
%105 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 10, i64 0
%106 = load float, float* %105
%107 = fpext float %106 to double
%108 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 10, i64 1
%109 = load float, float* %108
%110 = fpext float %109 to double
%111 = fadd float %106, %109
%112 = fpext float %111 to double
%113 = tail call i32 (i32, i8*, ...) @fprintf(i32 %104, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0), i32 11, double %107, double %110, double %112)
%114 = load i32, i32* @stdout
%115 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 11, i64 0
%116 = load float, float* %115
%117 = fpext float %116 to double
%118 = getelementptr inbounds [2 x float], [2 x float]* %0, i64 11, i64 1
%119 = load float, float* %118
%120 = fpext float %119 to double
%121 = fadd float %116, %119
%122 = fpext float %121 to double
%123 = tail call i32 (i32, i8*, ...) @fprintf(i32 %114, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0), i32 12, double %117, double %120, double %122)
ret void
}