#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 */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int atoi(char *);
int /*<<< orphan*/ fscanf(int /*<<< orphan*/ *, char *, float *);
int /*<<< orphan*/ printf(char *, int);
double sqrt(double);
void one_mnth(FILE *fp1, int yy, int mn, float month[30]) {
  int steps, i;
  char *regular[] = {"31", "28", "31", "30", "31", "30",
                     "31", "31", "30", "31", "30", "31"};
  char *leap[] = {"31", "29", "31", "30", "31", "30",
                  "31", "31", "30", "31", "30", "31"};
  float cc, min_prcp, min_tmax, min_tmin;
  float max_prcp, max_tmax, max_tmin;
  float prcp[31], tmax[31], tmin[31];
  double mean, SDprcp, SDtmax, SDtmin;
  double VARprcp, VARtmax, VARtmin;
  if (yy % 4 == 0)
    steps = atoi(leap[mn % 12]);
  if (yy % 4 != 0)
    steps = atoi(regular[mn % 12]);
  printf("steps %d\n", steps);
  month[0] = month[1] = month[2] = 0;
  min_prcp = min_tmax = min_tmin = 1000;
  max_prcp = max_tmax = max_tmin = -1000;
  for (i = 0; i < steps; i++) {
    fscanf(fp1, "%f", &cc);
    month[0] = month[0] + cc;
    if (cc < min_prcp)
      min_prcp = cc;
    if (cc > max_prcp)
      max_prcp = cc;
    prcp[i] = cc;
    fscanf(fp1, "%f", &cc);
    month[1] = month[1] + cc;
    if (cc < min_tmax)
      min_tmax = cc;
    if (cc > max_tmax)
      max_tmax = cc;
    tmax[i] = cc;
    fscanf(fp1, "%f", &cc);
    month[2] = month[2] + cc;
    if (cc < min_tmin)
      min_tmin = cc;
    if (cc > max_tmin)
      max_tmin = cc;
    tmin[i] = cc;
  }
  month[1] = month[1] / steps;
  month[2] = month[2] / steps;
  month[3] = min_prcp;
  month[4] = min_tmax;
  month[5] = min_tmin;
  month[6] = max_prcp;
  month[7] = max_tmax;
  month[8] = max_tmin;
  SDprcp = SDtmax = SDtmin = VARprcp = VARtmax = VARtmin = 0.00;
  for (i = 0; i < steps; i++) {
    SDprcp = SDprcp + prcp[i];
    SDtmax = SDtmax + tmax[i];
    SDtmin = SDtmin + tmin[i];
  }
  SDprcp = SDprcp / steps;
  SDtmax = SDtmax / steps;
  SDtmin = SDtmin / steps;
  for (i = 0; i < steps; i++) {
    VARprcp = VARprcp + ((prcp[i] - SDprcp) * (prcp[i] - SDprcp));
    VARtmax = VARtmax + ((tmax[i] - SDtmax) * (tmax[i] - SDtmax));
    VARtmin = VARtmin + ((tmin[i] - SDtmin) * (tmin[i] - SDtmin));
  }
  VARprcp = VARprcp / (steps - 1);
  VARtmax = VARtmax / (steps - 1);
  VARtmin = VARtmin / (steps - 1);
  SDprcp = sqrt(VARprcp);
  month[9] = SDprcp;
  SDtmax = sqrt(VARtmax);
  month[10] = SDtmax;
  SDtmin = sqrt(VARtmin);
  month[11] = SDtmin;
}


x86 assembly (clang, -O0):
<one_mnth>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2c0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
lea    -0x80(%rbp),%rdi
lea    0x2bec(%rip),%rsi
mov    $0x60,%edx
call   1050 <memcpy@plt>
lea    -0xe0(%rbp),%rdi
lea    0x2c34(%rip),%rsi
mov    $0x60,%edx
call   1050 <memcpy@plt>
mov    -0xc(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    11c8 <one_mnth+0x78>
mov    -0x10(%rbp),%eax
mov    $0xc,%ecx
cltd
idiv   %ecx
movslq %edx,%rax
mov    -0xe0(%rbp,%rax,8),%rdi
ff
call   1060 <atoi@plt>
mov    %eax,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     11f7 <one_mnth+0xa7>
mov    -0x10(%rbp),%eax
mov    $0xc,%ecx
cltd
idiv   %ecx
movslq %edx,%rax
mov    -0x80(%rbp,%rax,8),%rdi
call   1060 <atoi@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%esi
lea    0xe13(%rip),%rdi
call   1030 <printf@plt>
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movss  0xdd3(%rip),%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
movss  0xdc3(%rip),%xmm0
movss  %xmm0,-0xec(%rbp)
ff
movss  0xdb3(%rip),%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
movss  0xd9f(%rip),%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  0xd8f(%rip),%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
movss  0xd7f(%rip),%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1464 <one_mnth+0x314>
mov    -0x8(%rbp),%rdi
lea    0xd77(%rip),%rsi
lea    -0xe4(%rbp),%rdx
call   1040 <fscanf@plt>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
addss  -0xe4(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xe4(%rbp),%xmm1
ff
movss  -0xe8(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    12f4 <one_mnth+0x1a4>
movss  -0xe4(%rbp),%xmm0
ff
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0xe4(%rbp),%xmm0
ff
ucomiss -0xf4(%rbp),%xmm0
jbe    1319 <one_mnth+0x1c9>
movss  -0xe4(%rbp),%xmm0
ff
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0xe4(%rbp),%xmm0
ff
movslq -0x20(%rbp),%rax
movss  %xmm0,-0x180(%rbp,%rax,4)
ff ff
mov    -0x8(%rbp),%rdi
lea    0xce5(%rip),%rsi
lea    -0xe4(%rbp),%rdx
call   1040 <fscanf@plt>
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
addss  -0xe4(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xe4(%rbp),%xmm1
ff
movss  -0xec(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1388 <one_mnth+0x238>
movss  -0xe4(%rbp),%xmm0
ff
movss  %xmm0,-0xec(%rbp)
ff
movss  -0xe4(%rbp),%xmm0
ff
ucomiss -0xf8(%rbp),%xmm0
jbe    13ad <one_mnth+0x25d>
movss  -0xe4(%rbp),%xmm0
ff
movss  %xmm0,-0xf8(%rbp)
ff
movss  -0xe4(%rbp),%xmm0
ff
movslq -0x20(%rbp),%rax
movss  %xmm0,-0x200(%rbp,%rax,4)
ff ff
mov    -0x8(%rbp),%rdi
lea    0xc51(%rip),%rsi
lea    -0xe4(%rbp),%rdx
call   1040 <fscanf@plt>
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
addss  -0xe4(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0xe4(%rbp),%xmm1
ff
movss  -0xf0(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    141c <one_mnth+0x2cc>
movss  -0xe4(%rbp),%xmm0
ff
movss  %xmm0,-0xf0(%rbp)
ff
movss  -0xe4(%rbp),%xmm0
ff
ucomiss -0xfc(%rbp),%xmm0
jbe    1441 <one_mnth+0x2f1>
movss  -0xe4(%rbp),%xmm0
ff
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0xe4(%rbp),%xmm0
ff
movslq -0x20(%rbp),%rax
movss  %xmm0,-0x280(%rbp,%rax,4)
ff ff
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1290 <one_mnth+0x140>
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtsi2ssl -0x1c(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtsi2ssl -0x1c(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0xe8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0xec(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0xf0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0xf4(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0xf8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0xfc(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x20(%rax)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2b8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2b0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2a8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2a0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x298(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x290(%rbp)
ff
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15d2 <one_mnth+0x482>
movsd  -0x290(%rbp),%xmm0
ff
movslq -0x20(%rbp),%rax
movss  -0x180(%rbp,%rax,4),%xmm1
ff ff
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x290(%rbp)
ff
movsd  -0x298(%rbp),%xmm0
ff
movslq -0x20(%rbp),%rax
movss  -0x200(%rbp,%rax,4),%xmm1
ff ff
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x298(%rbp)
ff
movsd  -0x2a0(%rbp),%xmm0
ff
movslq -0x20(%rbp),%rax
movss  -0x280(%rbp,%rax,4),%xmm1
ff ff
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a0(%rbp)
ff
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1549 <one_mnth+0x3f9>
movsd  -0x290(%rbp),%xmm0
ff
cvtsi2sdl -0x1c(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x290(%rbp)
ff
movsd  -0x298(%rbp),%xmm0
ff
cvtsi2sdl -0x1c(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x298(%rbp)
ff
movsd  -0x2a0(%rbp),%xmm0
ff
cvtsi2sdl -0x1c(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a0(%rbp)
ff
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    171c <one_mnth+0x5cc>
movsd  -0x2a8(%rbp),%xmm1
ff
movslq -0x20(%rbp),%rax
movss  -0x180(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
subsd  -0x290(%rbp),%xmm0
ff
movslq -0x20(%rbp),%rax
movss  -0x180(%rbp,%rax,4),%xmm2
ff ff
cvtss2sd %xmm2,%xmm2
subsd  -0x290(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a8(%rbp)
ff
movsd  -0x2b0(%rbp),%xmm1
ff
movslq -0x20(%rbp),%rax
movss  -0x200(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
subsd  -0x298(%rbp),%xmm0
ff
movslq -0x20(%rbp),%rax
movss  -0x200(%rbp,%rax,4),%xmm2
ff ff
cvtss2sd %xmm2,%xmm2
subsd  -0x298(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2b0(%rbp)
ff
movsd  -0x2b8(%rbp),%xmm1
ff
movslq -0x20(%rbp),%rax
movss  -0x280(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
subsd  -0x2a0(%rbp),%xmm0
ff
movslq -0x20(%rbp),%rax
movss  -0x280(%rbp,%rax,4),%xmm2
ff ff
cvtss2sd %xmm2,%xmm2
subsd  -0x2a0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2b8(%rbp)
ff
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1624 <one_mnth+0x4d4>
movsd  -0x2a8(%rbp),%xmm0
ff
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a8(%rbp)
ff
movsd  -0x2b0(%rbp),%xmm0
ff
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2b0(%rbp)
ff
movsd  -0x2b8(%rbp),%xmm0
ff
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2b8(%rbp)
ff
movsd  -0x2a8(%rbp),%xmm0
ff
call   1070 <sqrt@plt>
movsd  %xmm0,-0x290(%rbp)
ff
movsd  -0x290(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x24(%rax)
movsd  -0x2b0(%rbp),%xmm0
ff
call   1070 <sqrt@plt>
movsd  %xmm0,-0x298(%rbp)
ff
movsd  -0x298(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x28(%rax)
movsd  -0x2b8(%rbp),%xmm0
ff
call   1070 <sqrt@plt>
movsd  %xmm0,-0x2a0(%rbp)
ff
movsd  -0x2a0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x2c(%rax)
add    $0x2c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<one_mnth>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1c8,%rsp
mov    %rcx,%rbx
mov    %rdi,%rbp
movslq %edx,%rax
imul   $0x2aaaaaab,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
shr    $0x21,%rcx
add    %edx,%ecx
shl    $0x2,%ecx
lea    (%rcx,%rcx,2),%ecx
sub    %ecx,%eax
test   $0x3,%sil
cltq
lea    0x2c3d(%rip),%rcx
lea    0x2bd6(%rip),%rdx
cmove  %rcx,%rdx
mov    (%rdx,%rax,8),%rdi
call   1050 <atoi@plt>
mov    %eax,%r14d
lea    0xe73(%rip),%rdi
mov    %eax,%esi
call   1030 <printf@plt>
movl   $0x0,0x8(%rbx)
movq   $0x0,(%rbx)
mov    %r14d,%r13d
test   %r14d,%r14d
jle    131a <one_mnth+0x1da>
mov    %r14d,0x2c(%rsp)
movss  0xe35(%rip),%xmm1
movss  0xe29(%rip),%xmm0
xor    %r14d,%r14d
lea    0xe3d(%rip),%r15
lea    0x14(%rsp),%r12
movaps %xmm0,%xmm7
movaps %xmm0,%xmm5
movaps %xmm1,%xmm6
movaps %xmm1,%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  %xmm3,0xc(%rsp)
movss  %xmm6,0x10(%rsp)
movss  %xmm1,0x30(%rsp)
movss  %xmm5,0x8(%rsp)
movss  %xmm7,0x18(%rsp)
movss  %xmm0,0x20(%rsp)
mov    %rbp,%rdi
mov    %r15,%rsi
mov    %r12,%rdx
call   1040 <fscanf@plt>
movss  0x14(%rsp),%xmm1
movss  (%rbx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rbx)
movaps %xmm1,%xmm0
minss  0xc(%rsp),%xmm0
movss  %xmm0,0xc(%rsp)
movss  %xmm1,0x140(%rsp,%r14,4)
maxss  0x8(%rsp),%xmm1
movss  %xmm1,0x8(%rsp)
mov    %rbp,%rdi
mov    %r15,%rsi
mov    %r12,%rdx
call   1040 <fscanf@plt>
movss  0x14(%rsp),%xmm1
movss  0x4(%rbx),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x4(%rbx)
movaps %xmm1,%xmm0
minss  0x10(%rsp),%xmm0
movss  %xmm0,0x10(%rsp)
movss  %xmm1,0xc0(%rsp,%r14,4)
maxss  0x18(%rsp),%xmm1
movss  %xmm1,0x18(%rsp)
mov    %rbp,%rdi
mov    %r15,%rsi
mov    %r12,%rdx
call   1040 <fscanf@plt>
movss  0x10(%rsp),%xmm6
movss  0x18(%rsp),%xmm7
movss  0xc(%rsp),%xmm3
movss  0x8(%rsp),%xmm5
movss  0x14(%rsp),%xmm0
movss  0x8(%rbx),%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0x8(%rbx)
movaps %xmm0,%xmm1
minss  0x30(%rsp),%xmm1
movss  %xmm0,0x40(%rsp,%r14,4)
maxss  0x20(%rsp),%xmm0
add    $0x1,%r14
cmp    %r14,%r13
jne    1200 <one_mnth+0xc0>
movss  0x4(%rbx),%xmm8
mov    0x2c(%rsp),%r14d
jmp    133d <one_mnth+0x1fd>
movss  0xcde(%rip),%xmm5
movss  0xcda(%rip),%xmm3
xorps  %xmm2,%xmm2
xorps  %xmm8,%xmm8
movaps %xmm3,%xmm6
movaps %xmm3,%xmm1
movaps %xmm5,%xmm7
movaps %xmm5,%xmm0
cvtsi2ss %r14d,%xmm4
divss  %xmm4,%xmm8
movss  %xmm8,0x4(%rbx)
divss  %xmm4,%xmm2
movss  %xmm2,0x8(%rbx)
movss  %xmm3,0xc(%rbx)
movss  %xmm6,0x10(%rbx)
movss  %xmm1,0x14(%rbx)
movss  %xmm5,0x18(%rbx)
movss  %xmm7,0x1c(%rbx)
movss  %xmm0,0x20(%rbx)
xorps  %xmm1,%xmm1
test   %r14d,%r14d
jle    14b0 <one_mnth+0x370>
cmp    $0x1,%r14d
jne    1390 <one_mnth+0x250>
xorps  %xmm2,%xmm2
xorps  %xmm0,%xmm0
xor    %eax,%eax
jmp    1403 <one_mnth+0x2c3>
mov    %r13d,%ecx
and    $0xfffffffe,%ecx
xorps  %xmm2,%xmm2
xorps  %xmm0,%xmm0
xor    %eax,%eax
xchg   %ax,%ax
movss  0xc0(%rsp,%rax,4),%xmm3
movss  0xc4(%rsp,%rax,4),%xmm4
movss  0x140(%rsp,%rax,4),%xmm5
unpcklps %xmm3,%xmm5
movss  0x144(%rsp,%rax,4),%xmm3
unpcklps %xmm4,%xmm3
cvtps2pd %xmm5,%xmm4
addpd  %xmm2,%xmm4
movss  0x40(%rsp,%rax,4),%xmm2
movss  0x44(%rsp,%rax,4),%xmm5
xorps  %xmm6,%xmm6
cvtss2sd %xmm2,%xmm6
addsd  %xmm0,%xmm6
cvtps2pd %xmm3,%xmm2
addpd  %xmm4,%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm5,%xmm0
addsd  %xmm6,%xmm0
add    $0x2,%rax
cmp    %rax,%rcx
jne    13a0 <one_mnth+0x260>
test   $0x1,%r13b
je     1433 <one_mnth+0x2f3>
movss  0xc0(%rsp,%rax,4),%xmm3
movss  0x140(%rsp,%rax,4),%xmm4
unpcklps %xmm3,%xmm4
cvtps2pd %xmm4,%xmm3
addpd  %xmm3,%xmm2
movss  0x40(%rsp,%rax,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm3,%xmm0
test   %r14d,%r14d
jle    14b0 <one_mnth+0x370>
xorps  %xmm3,%xmm3
cvtsi2sd %r14d,%xmm3
divsd  %xmm3,%xmm0
unpcklpd %xmm3,%xmm3
divpd  %xmm3,%xmm2
xorps  %xmm4,%xmm4
xorps  %xmm6,%xmm6
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movaps %xmm4,%xmm3
movss  0xc0(%rsp,%rax,4),%xmm4
movss  0x140(%rsp,%rax,4),%xmm5
unpcklps %xmm4,%xmm5
cvtps2pd %xmm5,%xmm7
subpd  %xmm2,%xmm7
mulpd  %xmm7,%xmm7
movapd %xmm7,%xmm4
addpd  %xmm3,%xmm4
movss  0x40(%rsp,%rax,4),%xmm5
cvtss2sd %xmm5,%xmm5
subsd  %xmm0,%xmm5
mulsd  %xmm5,%xmm5
addsd  %xmm5,%xmm6
add    $0x1,%rax
cmp    %rax,%r13
jne    1460 <one_mnth+0x320>
addpd  %xmm3,%xmm7
jmp    14b6 <one_mnth+0x376>
xorps  %xmm7,%xmm7
xorps  %xmm6,%xmm6
add    $0xffffffff,%r14d
xorps  %xmm2,%xmm2
cvtsi2sd %r14d,%xmm2
movapd %xmm7,%xmm0
divsd  %xmm2,%xmm0
unpckhpd %xmm7,%xmm7
divsd  %xmm2,%xmm7
ucomisd %xmm1,%xmm0
jb     14de <one_mnth+0x39e>
sqrtsd %xmm0,%xmm0
jmp    1507 <one_mnth+0x3c7>
movsd  %xmm6,0x20(%rsp)
movapd %xmm7,0x30(%rsp)
movsd  %xmm2,0x18(%rsp)
call   1060 <sqrt@plt>
movsd  0x18(%rsp),%xmm2
movapd 0x30(%rsp),%xmm7
movsd  0x20(%rsp),%xmm6
divsd  %xmm2,%xmm6
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x24(%rbx)
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm7
jb     1527 <one_mnth+0x3e7>
xorps  %xmm0,%xmm0
sqrtsd %xmm7,%xmm0
jmp    1540 <one_mnth+0x400>
movapd %xmm7,%xmm0
movsd  %xmm6,0x20(%rsp)
call   1060 <sqrt@plt>
xorpd  %xmm1,%xmm1
movsd  0x20(%rsp),%xmm6
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x28(%rbx)
ucomisd %xmm1,%xmm6
jb     1558 <one_mnth+0x418>
xorps  %xmm0,%xmm0
sqrtsd %xmm6,%xmm0
jmp    1561 <one_mnth+0x421>
movapd %xmm6,%xmm0
call   1060 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x2c(%rbx)
add    $0x1c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [3 x i8] c"31\00"
@.str.1 = [3 x i8] c"28\00"
@.str.2 = [3 x i8] c"30\00"
@__const.one_mnth.regular = [12 x i8*] [i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0)]
@.str.3 = [3 x i8] c"29\00"
@__const.one_mnth.leap = [12 x i8*] [i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0)]
@.str.4 = [10 x i8] c"steps %d\0A\00"
@.str.5 = [3 x i8] c"%f\00"
define void @one_mnth(i32* nocapture %0, i32 %1, i32 %2, float* nocapture %3) {
%5 = alloca float
%6 = alloca [31 x float]
%7 = alloca [31 x float]
%8 = alloca [31 x float]
%9 = bitcast float* %5 to i8*
%10 = bitcast [31 x float]* %6 to i8*
%11 = bitcast [31 x float]* %7 to i8*
%12 = bitcast [31 x float]* %8 to i8*
%13 = and i32 %1, 3
%14 = icmp eq i32 %13, 0
%15 = srem i32 %2, 12
%16 = sext i32 %15 to i64
%17 = select i1 %14, [12 x i8*]* @__const.one_mnth.leap, [12 x i8*]* @__const.one_mnth.regular
%18 = getelementptr inbounds [12 x i8*], [12 x i8*]* %17, i64 0, i64 %16
%19 = load i8*, i8** %18
%20 = tail call i32 @atoi(i8* %19)
%21 = tail call i32 @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.4, i64 0, i64 0), i32 %20)
%22 = getelementptr inbounds float, float* %3, i64 2
store float 0.000000e+00, float* %22
%23 = getelementptr inbounds float, float* %3, i64 1
store float 0.000000e+00, float* %23
store float 0.000000e+00, float* %3
%24 = icmp sgt i32 %20, 0
br i1 %24, label %25, label %66
25: ; preds = %4
%26 = zext i32 %20 to i64
br label %27
27: ; preds = %25, %27
%28 = phi i64 [ 0, %25 ], [ %62, %27 ]
%29 = phi float [ -1.000000e+03, %25 ], [ %60, %27 ]
%30 = phi float [ -1.000000e+03, %25 ], [ %51, %27 ]
%31 = phi float [ -1.000000e+03, %25 ], [ %42, %27 ]
%32 = phi float [ 1.000000e+03, %25 ], [ %58, %27 ]
%33 = phi float [ 1.000000e+03, %25 ], [ %49, %27 ]
%34 = phi float [ 1.000000e+03, %25 ], [ %40, %27 ]
%35 = call i32 @fscanf(i32* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), float* %5)
%36 = load float, float* %3
%37 = load float, float* %5
%38 = fadd float %36, %37
store float %38, float* %3
%39 = fcmp olt float %37, %34
%40 = select i1 %39, float %37, float %34
%41 = fcmp ogt float %37, %31
%42 = select i1 %41, float %37, float %31
%43 = getelementptr inbounds [31 x float], [31 x float]* %6, i64 0, i64 %28
store float %37, float* %43
%44 = call i32 @fscanf(i32* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), float* %5)
%45 = load float, float* %23
%46 = load float, float* %5
%47 = fadd float %45, %46
store float %47, float* %23
%48 = fcmp olt float %46, %33
%49 = select i1 %48, float %46, float %33
%50 = fcmp ogt float %46, %30
%51 = select i1 %50, float %46, float %30
%52 = getelementptr inbounds [31 x float], [31 x float]* %7, i64 0, i64 %28
store float %46, float* %52
%53 = call i32 @fscanf(i32* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), float* %5)
%54 = load float, float* %22
%55 = load float, float* %5
%56 = fadd float %54, %55
store float %56, float* %22
%57 = fcmp olt float %55, %32
%58 = select i1 %57, float %55, float %32
%59 = fcmp ogt float %55, %29
%60 = select i1 %59, float %55, float %29
%61 = getelementptr inbounds [31 x float], [31 x float]* %8, i64 0, i64 %28
store float %55, float* %61
%62 = add nuw nsw i64 %28, 1
%63 = icmp eq i64 %62, %26
br i1 %63, label %64, label %27
64: ; preds = %27
%65 = load float, float* %23
br label %66
66: ; preds = %64, %4
%67 = phi float [ 0.000000e+00, %4 ], [ %56, %64 ]
%68 = phi float [ 0.000000e+00, %4 ], [ %65, %64 ]
%69 = phi float [ 1.000000e+03, %4 ], [ %40, %64 ]
%70 = phi float [ 1.000000e+03, %4 ], [ %49, %64 ]
%71 = phi float [ 1.000000e+03, %4 ], [ %58, %64 ]
%72 = phi float [ -1.000000e+03, %4 ], [ %42, %64 ]
%73 = phi float [ -1.000000e+03, %4 ], [ %51, %64 ]
%74 = phi float [ -1.000000e+03, %4 ], [ %60, %64 ]
%75 = sitofp i32 %20 to float
%76 = fdiv float %68, %75
store float %76, float* %23
%77 = fdiv float %67, %75
store float %77, float* %22
%78 = getelementptr inbounds float, float* %3, i64 3
store float %69, float* %78
%79 = getelementptr inbounds float, float* %3, i64 4
store float %70, float* %79
%80 = getelementptr inbounds float, float* %3, i64 5
store float %71, float* %80
%81 = getelementptr inbounds float, float* %3, i64 6
store float %72, float* %81
%82 = getelementptr inbounds float, float* %3, i64 7
store float %73, float* %82
%83 = getelementptr inbounds float, float* %3, i64 8
store float %74, float* %83
br i1 %24, label %84, label %175
84: ; preds = %66
%85 = zext i32 %20 to i64
%86 = and i64 %85, 1
%87 = icmp eq i32 %20, 1
br i1 %87, label %123, label %88
88: ; preds = %84
%89 = and i64 %85, 4294967294
br label %90
90: ; preds = %90, %88
%91 = phi i64 [ 0, %88 ], [ %120, %90 ]
%92 = phi double [ 0.000000e+00, %88 ], [ %119, %90 ]
%93 = phi <2 x double> [ zeroinitializer, %88 ], [ %115, %90 ]
%94 = phi i64 [ 0, %88 ], [ %121, %90 ]
%95 = getelementptr inbounds [31 x float], [31 x float]* %6, i64 0, i64 %91
%96 = load float, float* %95
%97 = getelementptr inbounds [31 x float], [31 x float]* %7, i64 0, i64 %91
%98 = load float, float* %97
%99 = insertelement <2 x float> poison, float %96, i64 0
%100 = insertelement <2 x float> %99, float %98, i64 1
%101 = fpext <2 x float> %100 to <2 x double>
%102 = fadd <2 x double> %93, %101
%103 = getelementptr inbounds [31 x float], [31 x float]* %8, i64 0, i64 %91
%104 = load float, float* %103
%105 = fpext float %104 to double
%106 = fadd double %92, %105
%107 = or i64 %91, 1
%108 = getelementptr inbounds [31 x float], [31 x float]* %6, i64 0, i64 %107
%109 = load float, float* %108
%110 = getelementptr inbounds [31 x float], [31 x float]* %7, i64 0, i64 %107
%111 = load float, float* %110
%112 = insertelement <2 x float> poison, float %109, i64 0
%113 = insertelement <2 x float> %112, float %111, i64 1
%114 = fpext <2 x float> %113 to <2 x double>
%115 = fadd <2 x double> %102, %114
%116 = getelementptr inbounds [31 x float], [31 x float]* %8, i64 0, i64 %107
%117 = load float, float* %116
%118 = fpext float %117 to double
%119 = fadd double %106, %118
%120 = add nuw nsw i64 %91, 2
%121 = add i64 %94, 2
%122 = icmp eq i64 %121, %89
br i1 %122, label %123, label %90
123: ; preds = %90, %84
%124 = phi <2 x double> [ undef, %84 ], [ %115, %90 ]
%125 = phi double [ undef, %84 ], [ %119, %90 ]
%126 = phi i64 [ 0, %84 ], [ %120, %90 ]
%127 = phi double [ 0.000000e+00, %84 ], [ %119, %90 ]
%128 = phi <2 x double> [ zeroinitializer, %84 ], [ %115, %90 ]
%129 = icmp eq i64 %86, 0
br i1 %129, label %143, label %130
130: ; preds = %123
%131 = getelementptr inbounds [31 x float], [31 x float]* %6, i64 0, i64 %126
%132 = load float, float* %131
%133 = getelementptr inbounds [31 x float], [31 x float]* %7, i64 0, i64 %126
%134 = load float, float* %133
%135 = insertelement <2 x float> poison, float %132, i64 0
%136 = insertelement <2 x float> %135, float %134, i64 1
%137 = fpext <2 x float> %136 to <2 x double>
%138 = fadd <2 x double> %128, %137
%139 = getelementptr inbounds [31 x float], [31 x float]* %8, i64 0, i64 %126
%140 = load float, float* %139
%141 = fpext float %140 to double
%142 = fadd double %127, %141
br label %143
143: ; preds = %123, %130
%144 = phi <2 x double> [ %124, %123 ], [ %138, %130 ]
%145 = phi double [ %125, %123 ], [ %142, %130 ]
%146 = sitofp i32 %20 to double
%147 = insertelement <2 x double> poison, double %146, i64 0
%148 = shufflevector <2 x double> %147, <2 x double> poison, <2 x i32> zeroinitializer
%149 = fdiv <2 x double> %144, %148
%150 = fdiv double %145, %146
br i1 %24, label %151, label %175
151: ; preds = %143
%152 = zext i32 %20 to i64
br label %153
153: ; preds = %151, %153
%154 = phi i64 [ 0, %151 ], [ %171, %153 ]
%155 = phi double [ 0.000000e+00, %151 ], [ %170, %153 ]
%156 = phi <2 x double> [ zeroinitializer, %151 ], [ %165, %153 ]
%157 = getelementptr inbounds [31 x float], [31 x float]* %6, i64 0, i64 %154
%158 = load float, float* %157
%159 = getelementptr inbounds [31 x float], [31 x float]* %7, i64 0, i64 %154
%160 = load float, float* %159
%161 = insertelement <2 x float> poison, float %158, i64 0
%162 = insertelement <2 x float> %161, float %160, i64 1
%163 = fpext <2 x float> %162 to <2 x double>
%164 = fsub <2 x double> %163, %149
%165 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %164, <2 x double> %164, <2 x double> %156)
%166 = getelementptr inbounds [31 x float], [31 x float]* %8, i64 0, i64 %154
%167 = load float, float* %166
%168 = fpext float %167 to double
%169 = fsub double %168, %150
%170 = call double @llvm.fmuladd.f64(double %169, double %169, double %155)
%171 = add nuw nsw i64 %154, 1
%172 = icmp eq i64 %171, %152
br i1 %172, label %173, label %153
173: ; preds = %153
%174 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %164, <2 x double> %164, <2 x double> %156)
br label %175
175: ; preds = %173, %66, %143
%176 = phi double [ 0.000000e+00, %143 ], [ 0.000000e+00, %66 ], [ %170, %173 ]
%177 = phi <2 x double> [ zeroinitializer, %143 ], [ zeroinitializer, %66 ], [ %174, %173 ]
%178 = add nsw i32 %20, -1
%179 = sitofp i32 %178 to double
%180 = extractelement <2 x double> %177, i64 0
%181 = fdiv double %180, %179
%182 = extractelement <2 x double> %177, i64 1
%183 = fdiv double %182, %179
%184 = fdiv double %176, %179
%185 = call double @sqrt(double %181)
%186 = fptrunc double %185 to float
%187 = getelementptr inbounds float, float* %3, i64 9
store float %186, float* %187
%188 = call double @sqrt(double %183)
%189 = fptrunc double %188 to float
%190 = getelementptr inbounds float, float* %3, i64 10
store float %189, float* %190
%191 = call double @sqrt(double %184)
%192 = fptrunc double %191 to float
%193 = getelementptr inbounds float, float* %3, i64 11
store float %192, float* %193
ret void
}